Source Code
Overview
ETH Balance
0 ETH
More Info
ContractCreator
Multichain Info
N/A
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
SgxVerifier
Compiler Version
v0.8.24+commit.e11b9ed9
Optimization Enabled:
Yes with 200 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.24; import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; import "../L1/ITaikoL1.sol"; import "../common/EssentialContract.sol"; import "../common/LibStrings.sol"; import "../automata-attestation/interfaces/IAttestation.sol"; import "../automata-attestation/lib/QuoteV3Auth/V3Struct.sol"; import "./libs/LibPublicInput.sol"; import "./IVerifier.sol"; /// @title SgxVerifier /// @notice This contract is the implementation of verifying SGX signature proofs /// onchain. /// @dev Please see references below: /// - Reference #1: https://ethresear.ch/t/2fa-zk-rollups-using-sgx/14462 /// - Reference #2: https://github.com/gramineproject/gramine/discussions/1579 /// @custom:security-contact [email protected] contract SgxVerifier is EssentialContract, IVerifier { /// @dev Each public-private key pair (Ethereum address) is generated within /// the SGX program when it boots up. The off-chain remote attestation /// ensures the validity of the program hash and has the capability of /// bootstrapping the network with trustworthy instances. struct Instance { address addr; uint64 validSince; } /// @notice The expiry time for the SGX instance. uint64 public constant INSTANCE_EXPIRY = 365 days; /// @notice A security feature, a delay until an instance is enabled when using onchain RA /// verification uint64 public constant INSTANCE_VALIDITY_DELAY = 0; /// @dev For gas savings, we shall assign each SGX instance with an id that when we need to /// set a new pub key, just write storage once. /// Slot 1. uint256 public nextInstanceId; /// @dev One SGX instance is uniquely identified (on-chain) by it's ECDSA public key /// (or rather ethereum address). Once that address is used (by proof verification) it has to be /// overwritten by a new one (representing the same instance). This is due to side-channel /// protection. Also this public key shall expire after some time /// (for now it is a long enough 6 months setting). /// Slot 2. mapping(uint256 instanceId => Instance instance) public instances; /// @dev One address shall be registered (during attestation) only once, otherwise it could /// bypass this contract's expiry check by always registering with the same attestation and /// getting multiple valid instanceIds. While during proving, it is technically possible to /// register the old addresses, it is less of a problem, because the instanceId would be the /// same for those addresses and if deleted - the attestation cannot be reused anyways. /// Slot 3. mapping(address instanceAddress => bool alreadyAttested) public addressRegistered; uint256[47] private __gap; /// @notice Emitted when a new SGX instance is added to the registry, or replaced. /// @param id The ID of the SGX instance. /// @param instance The address of the SGX instance. /// @param replaced The address of the SGX instance that was replaced. If it is the first /// instance, this value is zero address. /// @param validSince The time since the instance is valid. event InstanceAdded( uint256 indexed id, address indexed instance, address replaced, uint256 validSince ); /// @notice Emitted when an SGX instance is deleted from the registry. /// @param id The ID of the SGX instance. /// @param instance The address of the SGX instance. event InstanceDeleted(uint256 indexed id, address indexed instance); error SGX_ALREADY_ATTESTED(); error SGX_INVALID_ATTESTATION(); error SGX_INVALID_INSTANCE(); error SGX_INVALID_PROOF(); error SGX_RA_NOT_SUPPORTED(); /// @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 of the {AddressManager} contract. function init(address _owner, address _addressManager) external initializer { __Essential_init(_owner, _addressManager); } /// @notice Adds trusted SGX instances to the registry. /// @param _instances The address array of trusted SGX instances. /// @return The respective instanceId array per addresses. function addInstances(address[] calldata _instances) external onlyOwner returns (uint256[] memory) { return _addInstances(_instances, true); } /// @notice Deletes SGX instances from the registry. /// @param _ids The ids array of SGX instances. function deleteInstances(uint256[] calldata _ids) external onlyFromOwnerOrNamed(LibStrings.B_ROLLUP_WATCHDOG) { for (uint256 i; i < _ids.length; ++i) { uint256 idx = _ids[i]; if (instances[idx].addr == address(0)) revert SGX_INVALID_INSTANCE(); emit InstanceDeleted(idx, instances[idx].addr); delete instances[idx]; } } /// @notice Adds an SGX instance after the attestation is verified /// @param _attestation The parsed attestation quote. /// @return The respective instanceId function registerInstance(V3Struct.ParsedV3QuoteStruct calldata _attestation) external returns (uint256) { address automataDcapAttestation = (resolve(LibStrings.B_AUTOMATA_DCAP_ATTESTATION, true)); if (automataDcapAttestation == address(0)) { revert SGX_RA_NOT_SUPPORTED(); } (bool verified,) = IAttestation(automataDcapAttestation).verifyParsedQuote(_attestation); if (!verified) revert SGX_INVALID_ATTESTATION(); address[] memory _address = new address[](1); _address[0] = address(bytes20(_attestation.localEnclaveReport.reportData)); return _addInstances(_address, false)[0]; } /// @inheritdoc IVerifier function verifyProof( Context calldata _ctx, TaikoData.Transition calldata _tran, TaikoData.TierProof calldata _proof ) external onlyFromNamed(LibStrings.B_TAIKO) { // Do not run proof verification to contest an existing proof if (_ctx.isContesting) return; // Size is: 89 bytes // 4 bytes + 20 bytes + 65 bytes (signature) = 89 if (_proof.data.length != 89) revert SGX_INVALID_PROOF(); uint32 id = uint32(bytes4(_proof.data[:4])); address newInstance = address(bytes20(_proof.data[4:24])); uint64 chainId = ITaikoL1(resolve(LibStrings.B_TAIKO, false)).getConfig().chainId; address oldInstance = ECDSA.recover( LibPublicInput.hashPublicInputs( _tran, address(this), newInstance, _ctx.prover, _ctx.metaHash, chainId ), _proof.data[24:] ); if (!_isInstanceValid(id, oldInstance)) revert SGX_INVALID_INSTANCE(); _replaceInstance(id, oldInstance, newInstance); } function _addInstances( address[] memory _instances, bool instantValid ) private returns (uint256[] memory ids) { ids = new uint256[](_instances.length); uint64 validSince = uint64(block.timestamp); if (!instantValid) { validSince += INSTANCE_VALIDITY_DELAY; } for (uint256 i; i < _instances.length; ++i) { if (addressRegistered[_instances[i]]) revert SGX_ALREADY_ATTESTED(); addressRegistered[_instances[i]] = true; if (_instances[i] == address(0)) revert SGX_INVALID_INSTANCE(); instances[nextInstanceId] = Instance(_instances[i], validSince); ids[i] = nextInstanceId; emit InstanceAdded(nextInstanceId, _instances[i], address(0), validSince); ++nextInstanceId; } } function _replaceInstance(uint256 id, address oldInstance, address newInstance) private { // Replacing an instance means, it went through a cooldown (if added by on-chain RA) so no // need to have a cooldown instances[id] = Instance(newInstance, uint64(block.timestamp)); emit InstanceAdded(id, newInstance, oldInstance, block.timestamp); } function _isInstanceValid(uint256 id, address instance) private view returns (bool) { if (instance == address(0)) return false; if (instance != instances[id].addr) return false; return instances[id].validSince <= block.timestamp && block.timestamp <= instances[id].validSince + INSTANCE_EXPIRY; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; import "../Strings.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 ECDSA { 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. * * 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) { 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. /// @solidity memory-safe-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 { 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 = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 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 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 message) { // 32 is the length in bytes of hash, // enforced by the type signature above /// @solidity memory-safe-assembly assembly { mstore(0x00, "\x19Ethereum Signed Message:\n32") mstore(0x1c, hash) message := keccak256(0x00, 0x3c) } } /** * @dev Returns an Ethereum Signed Message, created from `s`. 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(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @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 data) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) mstore(ptr, "\x19\x01") mstore(add(ptr, 0x02), domainSeparator) mstore(add(ptr, 0x22), structHash) data := keccak256(ptr, 0x42) } } /** * @dev Returns an Ethereum Signed Data with intended validator, created from a * `validator` and `data` according to the version 0 of EIP-191. * * See {recover}. */ function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x00", validator, data)); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.24; import "./TaikoData.sol"; /// @title ITaikoL1 /// @custom:security-contact [email protected] interface ITaikoL1 { /// @notice Proposes a Taiko L2 block. /// @param _params Block parameters, currently an encoded BlockParams object. /// @param _txList txList data if calldata is used for DA. /// @return meta_ The metadata of the proposed L2 block. /// @return deposits_ The Ether deposits processed. function proposeBlock( bytes calldata _params, bytes calldata _txList ) external payable returns (TaikoData.BlockMetadata memory meta_, TaikoData.EthDeposit[] memory deposits_); /// @notice Proves or contests a block transition. /// @param _blockId The index of the block to prove. This is also used to /// select the right implementation version. /// @param _input An abi-encoded (TaikoData.BlockMetadata, TaikoData.Transition, /// TaikoData.TierProof) tuple. function proveBlock(uint64 _blockId, bytes calldata _input) external; /// @notice Verifies up to a certain number of blocks. /// @param _maxBlocksToVerify Max number of blocks to verify. function verifyBlocks(uint64 _maxBlocksToVerify) external; /// @notice Gets the configuration of the TaikoL1 contract. /// @return Config struct containing configuration parameters. function getConfig() external view returns (TaikoData.Config memory); }
// SPDX-License-Identifier: MIT pragma 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 [email protected] abstract 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 REENTRANT_CALL(); error INVALID_PAUSE_STATUS(); error ZERO_ADDR_MANAGER(); /// @dev Modifier that ensures the caller is the owner or resolved address of a given name. /// @param _name The name to check against. modifier onlyFromOwnerOrNamed(bytes32 _name) { if (msg.sender != owner() && msg.sender != resolve(_name, true)) revert RESOLVER_DENIED(); _; } modifier nonReentrant() { if (_loadReentryLock() == _TRUE) revert REENTRANT_CALL(); _storeReentryLock(_TRUE); _; _storeReentryLock(_FALSE); } modifier whenPaused() { if (!paused()) revert INVALID_PAUSE_STATUS(); _; } modifier whenNotPaused() { if (paused()) revert INVALID_PAUSE_STATUS(); _; } /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } /// @notice Pauses the contract. function pause() public virtual whenNotPaused { __paused = _TRUE; emit Paused(msg.sender); // We call the authorize function here to avoid: // Warning (5740): Unreachable code. _authorizePause(msg.sender, true); } /// @notice Unpauses the contract. function unpause() public virtual whenPaused { __paused = _FALSE; lastUnpausedAt = uint64(block.timestamp); emit Unpaused(msg.sender); // We call the authorize function here to avoid: // Warning (5740): Unreachable code. _authorizePause(msg.sender, false); } /// @notice Returns true if the contract is paused, and false otherwise. /// @return true if paused, false otherwise. function paused() public view returns (bool) { return __paused == _TRUE; } /// @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 of the {AddressManager} contract. function __Essential_init(address _owner, address _addressManager) internal onlyInitializing { if (_addressManager == address(0)) revert ZERO_ADDR_MANAGER(); __Essential_init(_owner); __AddressResolver_init(_addressManager); } function __Essential_init(address _owner) internal virtual { _transferOwnership(_owner == address(0) ? msg.sender : _owner); __paused = _FALSE; } function _authorizeUpgrade(address) internal virtual override onlyOwner { } function _authorizePause(address, bool) internal virtual onlyOwner { } // Stores the reentry lock function _storeReentryLock(uint8 _reentry) internal virtual { if (LibNetwork.isDencunSupported(block.chainid)) { assembly { tstore(_REENTRY_SLOT, _reentry) } } else { __reentry = _reentry; } } // Loads the reentry lock function _loadReentryLock() internal view virtual returns (uint8 reentry_) { if (LibNetwork.isDencunSupported(block.chainid)) { assembly { reentry_ := tload(_REENTRY_SLOT) } } else { reentry_ = __reentry; } } function _inNonReentrant() internal view returns (bool) { return _loadReentryLock() == _TRUE; } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.24; /// @title LibStrings /// @custom:security-contact [email protected] library LibStrings { /// @notice bytes32 representation of the string "chain_pauser". bytes32 internal constant B_CHAIN_PAUSER = bytes32("chain_pauser"); /// @notice bytes32 representation of the string "snapshooter". bytes32 internal constant B_SNAPSHOOTER = bytes32("snapshooter"); /// @notice bytes32 representation of the string "withdrawer". bytes32 internal constant B_WITHDRAWER = bytes32("withdrawer"); /// @notice bytes32 representation of the string "proposer". bytes32 internal constant B_PROPOSER = bytes32("proposer"); /// @notice bytes32 representation of the string "proposer_one". bytes32 internal constant B_PROPOSER_ONE = bytes32("proposer_one"); /// @notice bytes32 representation of the string "signal_service". bytes32 internal constant B_SIGNAL_SERVICE = bytes32("signal_service"); /// @notice bytes32 representation of the string "taiko_token". bytes32 internal constant B_TAIKO_TOKEN = bytes32("taiko_token"); /// @notice bytes32 representation of the string "taiko". bytes32 internal constant B_TAIKO = bytes32("taiko"); /// @notice bytes32 representation of the string "bridge". bytes32 internal constant B_BRIDGE = bytes32("bridge"); /// @notice bytes32 representation of the string "erc20_vault". bytes32 internal constant B_ERC20_VAULT = bytes32("erc20_vault"); /// @notice bytes32 representation of the string "bridged_erc20". bytes32 internal constant B_BRIDGED_ERC20 = bytes32("bridged_erc20"); /// @notice bytes32 representation of the string "erc1155_vault". bytes32 internal constant B_ERC1155_VAULT = bytes32("erc1155_vault"); /// @notice bytes32 representation of the string "bridged_erc1155". bytes32 internal constant B_BRIDGED_ERC1155 = bytes32("bridged_erc1155"); /// @notice bytes32 representation of the string "erc721_vault". bytes32 internal constant B_ERC721_VAULT = bytes32("erc721_vault"); /// @notice bytes32 representation of the string "bridged_erc721". bytes32 internal constant B_BRIDGED_ERC721 = bytes32("bridged_erc721"); /// @notice bytes32 representation of the string "bridge_watchdog". bytes32 internal constant B_BRIDGE_WATCHDOG = bytes32("bridge_watchdog"); /// @notice bytes32 representation of the string "rollup_watchdog". bytes32 internal constant B_ROLLUP_WATCHDOG = bytes32("rollup_watchdog"); /// @notice bytes32 representation of the string "tier_provider". bytes32 internal constant B_TIER_PROVIDER = bytes32("tier_provider"); /// @notice The tier name for optimistic proofs - expected to only be used for testnets. For /// production we do not plan to have optimistic type of proving first, but future will tell if /// L3s, app-chains or other 3rd parties would be willing to do so. bytes32 internal constant B_TIER_OP = bytes32("tier_optimistic"); /// @notice bytes32 representation of the string "guardian_prover". bytes32 internal constant B_GUARDIAN_PROVER = bytes32("guardian_prover"); /// @notice bytes32 representation of the string "automata_dcap_attestation". bytes32 internal constant B_AUTOMATA_DCAP_ATTESTATION = bytes32("automata_dcap_attestation"); /// @notice bytes32 representation of the string "PROVER_ASSIGNMENT". bytes32 public constant B_PROVER_ASSIGNMENT = bytes32("PROVER_ASSIGNMENT"); /// @notice Keccak hash of the string "RETURN_LIVENESS_BOND". bytes32 internal constant H_RETURN_LIVENESS_BOND = keccak256("RETURN_LIVENESS_BOND"); /// @notice Keccak hash of the string "STATE_ROOT". bytes32 internal constant H_STATE_ROOT = keccak256("STATE_ROOT"); /// @notice Keccak hash of the string "SIGNAL_ROOT". bytes32 internal constant H_SIGNAL_ROOT = keccak256("SIGNAL_ROOT"); /// @notice Constant string "SIGNAL". string internal constant S_SIGNAL = "SIGNAL"; }
//SPDX-License-Identifier: MIT pragma solidity 0.8.24; import { V3Struct } from "../lib/QuoteV3Auth/V3Struct.sol"; /// @title IAttestation /// @custom:security-contact [email protected] interface IAttestation { function verifyAttestation(bytes calldata data) external returns (bool); function verifyParsedQuote(V3Struct.ParsedV3QuoteStruct calldata v3quote) external returns (bool success, bytes memory retData); }
//SPDX-License-Identifier: MIT pragma solidity 0.8.24; /// @title V3Struct /// @custom:security-contact [email protected] library V3Struct { struct Header { bytes2 version; bytes2 attestationKeyType; bytes4 teeType; bytes2 qeSvn; bytes2 pceSvn; bytes16 qeVendorId; bytes20 userData; } struct EnclaveReport { bytes16 cpuSvn; bytes4 miscSelect; bytes28 reserved1; bytes16 attributes; bytes32 mrEnclave; bytes32 reserved2; bytes32 mrSigner; bytes reserved3; // 96 bytes uint16 isvProdId; uint16 isvSvn; bytes reserved4; // 60 bytes bytes reportData; // 64 bytes - For QEReports, this contains the hash of the concatenation // of attestation key and QEAuthData } struct QEAuthData { uint16 parsedDataSize; bytes data; } struct CertificationData { uint16 certType; // todo! In encoded path, we need to calculate the size of certDataArray // certDataSize = len(join((BEGIN_CERT, certArray[i], END_CERT) for i in 0..3)) // But for plain bytes path, we don't need that. uint32 certDataSize; bytes[3] decodedCertDataArray; // base64 decoded cert bytes array } struct ECDSAQuoteV3AuthData { bytes ecdsa256BitSignature; // 64 bytes bytes ecdsaAttestationKey; // 64 bytes EnclaveReport pckSignedQeReport; // 384 bytes bytes qeReportSignature; // 64 bytes QEAuthData qeAuthData; CertificationData certification; } struct ParsedV3QuoteStruct { Header header; EnclaveReport localEnclaveReport; ECDSAQuoteV3AuthData v3AuthData; } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.24; import "../../L1/TaikoData.sol"; /// @title LibPublicInput /// @notice A library for handling hashing the so-called public input hash, used by sgx and zk /// proofs. /// @custom:security-contact [email protected] library LibPublicInput { /// @notice Hashes the public input for the proof verification. /// @param _tran The transition to verify. /// @param _verifierContract The contract address which as current verifier. /// @param _newInstance The new instance address. For SGX it is the new signer address, for ZK /// this variable is not used and must have value address(0). /// @param _prover The prover address. /// @param _metaHash The meta hash. /// @param _chainId The chain id. /// @return The public input hash. function hashPublicInputs( TaikoData.Transition memory _tran, address _verifierContract, address _newInstance, address _prover, bytes32 _metaHash, uint64 _chainId ) internal pure returns (bytes32) { return keccak256( abi.encode( "VERIFY_PROOF", _chainId, _verifierContract, _tran, _newInstance, _prover, _metaHash ) ); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.24; import "../L1/TaikoData.sol"; /// @title IVerifier /// @notice Defines the function that handles proof verification. /// @custom:security-contact [email protected] interface IVerifier { struct Context { bytes32 metaHash; bytes32 blobHash; address prover; uint64 blockId; bool isContesting; bool blobUsed; address msgSender; } /// @notice Verifies a proof. /// @param _ctx The context of the proof verification. /// @param _tran The transition to verify. /// @param _proof The proof to verify. function verifyProof( Context calldata _ctx, TaikoData.Transition calldata _tran, TaikoData.TierProof calldata _proof ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; import "./math/SignedMath.sol"; /** * @dev String operations. */ library Strings { 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 = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.24; /// @title TaikoData /// @notice This library defines various data structures used in the Taiko /// protocol. /// @custom:security-contact [email protected] library TaikoData { /// @dev Struct holding Taiko configuration parameters. See {TaikoConfig}. struct Config { // --------------------------------------------------------------------- // Group 1: General configs // --------------------------------------------------------------------- // The chain ID of the network where Taiko contracts are deployed. uint64 chainId; // --------------------------------------------------------------------- // Group 2: Block level configs // --------------------------------------------------------------------- // The maximum number of proposals allowed in a single block. uint64 blockMaxProposals; // Size of the block ring buffer, allowing extra space for proposals. uint64 blockRingBufferSize; // The maximum number of verifications allowed when a block is proposed. uint64 maxBlocksToVerifyPerProposal; // The maximum gas limit allowed for a block. uint32 blockMaxGasLimit; // --------------------------------------------------------------------- // Group 3: Proof related configs // --------------------------------------------------------------------- // The amount of Taiko token as a prover liveness bond uint96 livenessBond; // --------------------------------------------------------------------- // Group 4: Cross-chain sync // --------------------------------------------------------------------- // The max number of L2 blocks that can stay unsynced on L1 (a value of zero disables // syncing) uint8 blockSyncThreshold; } /// @dev Struct representing prover fees per given tier struct TierFee { uint16 tier; uint128 fee; } /// @dev A proof and the tier of proof it belongs to struct TierProof { uint16 tier; bytes data; } /// @dev Hook and it's data (currently used only during proposeBlock) struct HookCall { address hook; bytes data; } /// @dev Represents proposeBlock's _data input parameter struct BlockParams { address assignedProver; address coinbase; bytes32 extraData; bytes32 parentMetaHash; HookCall[] hookCalls; bytes signature; } /// @dev Struct containing data only required for proving a block /// Note: On L2, `block.difficulty` is the pseudo name of /// `block.prevrandao`, which returns a random number provided by the layer /// 1 chain. struct BlockMetadata { bytes32 l1Hash; bytes32 difficulty; bytes32 blobHash; //or txListHash (if Blob not yet supported) bytes32 extraData; bytes32 depositsHash; address coinbase; // L2 coinbase, uint64 id; uint32 gasLimit; uint64 timestamp; uint64 l1Height; uint16 minTier; bool blobUsed; bytes32 parentMetaHash; address sender; // a.k.a proposer } /// @dev Struct representing transition to be proven. struct Transition { bytes32 parentHash; bytes32 blockHash; bytes32 stateRoot; bytes32 graffiti; // Arbitrary data that the prover can use for various purposes. } /// @dev Struct representing state transition data. /// 10 slots reserved for upgradability, 6 slots used. struct TransitionState { bytes32 key; // slot 1, only written/read for the 1st state transition. bytes32 blockHash; // slot 2 bytes32 stateRoot; // slot 3 address prover; // slot 4 uint96 validityBond; address contester; // slot 5 uint96 contestBond; uint64 timestamp; // slot 6 (90 bits) uint16 tier; uint8 __reserved1; } /// @dev Struct containing data required for verifying a block. /// 3 slots used. struct Block { bytes32 metaHash; // slot 1 address assignedProver; // slot 2 uint96 livenessBond; uint64 blockId; // slot 3 uint64 proposedAt; // timestamp uint64 proposedIn; // L1 block number, required/used by node/client. uint32 nextTransitionId; uint32 verifiedTransitionId; } /// @dev Struct representing an Ethereum deposit. /// 2 slot used. Currently removed from protocol, but to be backwards compatible, the struct and /// return values stayed for now. struct EthDeposit { address recipient; uint96 amount; uint64 id; } /// @dev Forge is only able to run coverage in case the contracts by default /// capable of compiling without any optimization (neither optimizer runs, /// no compiling --via-ir flag). /// In order to resolve stack too deep without optimizations, we needed to /// introduce outsourcing vars into structs below. struct SlotA { uint64 genesisHeight; uint64 genesisTimestamp; uint64 lastSyncedBlockId; uint64 lastSynecdAt; } struct SlotB { uint64 numBlocks; uint64 lastVerifiedBlockId; bool provingPaused; uint8 __reservedB1; uint16 __reservedB2; uint32 __reservedB3; uint64 lastUnpausedAt; } /// @dev Struct holding the state variables for the {TaikoL1} contract. struct State { // Ring buffer for proposed blocks and a some recent verified blocks. mapping(uint64 blockId_mod_blockRingBufferSize => Block blk) blocks; // Indexing to transition ids (ring buffer not possible) mapping(uint64 blockId => mapping(bytes32 parentHash => uint32 transitionId)) transitionIds; // Ring buffer for transitions mapping( uint64 blockId_mod_blockRingBufferSize => mapping(uint32 transitionId => TransitionState ts) ) transitions; // Ring buffer for Ether deposits bytes32 __reserve1; SlotA slotA; // slot 5 SlotB slotB; // slot 6 uint256[44] __gap; } }
// 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-assignment address 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. */ modifier notDelegated() { require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall"); _; } /** * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the * implementation. It is used to validate the implementation's compatibility when performing an upgrade. * * 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. This is guaranteed by the `notDelegated` modifier. */ function proxiableUUID() external view virtual override notDelegated returns (bytes32) { return _IMPLEMENTATION_SLOT; } /** * @dev Upgrade the implementation of the proxy to `newImplementation`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. * * @custom:oz-upgrades-unsafe-allow-reachable delegatecall */ function upgradeTo(address newImplementation) public virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, new bytes(0), false); } /** * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call * encoded in `data`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. * * @custom:oz-upgrades-unsafe-allow-reachable delegatecall */ function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, data, true); } /** * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by * {upgradeTo} and {upgradeToAndCall}. * * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. * * ```solidity * function _authorizeUpgrade(address) internal override onlyOwner {} * ``` */ function _authorizeUpgrade(address newImplementation) internal virtual; }
// 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. */ function transferOwnership(address newOwner) public virtual override onlyOwner { _pendingOwner = newOwner; emit OwnershipTransferStarted(owner(), newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner. * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual override { delete _pendingOwner; super._transferOwnership(newOwner); } /** * @dev The new owner accepts the ownership transfer. */ function acceptOwnership() public virtual { address sender = _msgSender(); require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner"); _transferOwnership(sender); } /** * @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[49] private __gap; }
// SPDX-License-Identifier: MIT pragma 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 [email protected] abstract 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(); _; } /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } /// @inheritdoc IAddressResolver function resolve( bytes32 _name, bool _allowZeroAddress ) public view virtual returns (address payable) { return _resolve(uint64(block.chainid), _name, _allowZeroAddress); } /// @inheritdoc IAddressResolver function resolve( uint64 _chainId, bytes32 _name, bool _allowZeroAddress ) public view virtual returns (address payable) { return _resolve(_chainId, _name, _allowZeroAddress); } /// @dev Initialization method for setting up AddressManager reference. /// @param _addressManager Address of the AddressManager. function __AddressResolver_init(address _addressManager) internal virtual onlyInitializing { if (block.chainid > type(uint64).max) { revert RESOLVER_UNEXPECTED_CHAINID(); } addressManager = _addressManager; } /// @dev Helper method to resolve name-to-address. /// @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 addr_ Address associated with the given name on the specified /// chain. function _resolve( uint64 _chainId, bytes32 _name, bool _allowZeroAddress ) private view returns (address payable addr_) { address _addressManager = addressManager; if (_addressManager == address(0)) revert RESOLVER_INVALID_MANAGER(); addr_ = payable(IAddressManager(_addressManager).getAddress(_chainId, _name)); if (!_allowZeroAddress && addr_ == address(0)) { revert RESOLVER_ZERO_ADDR(_chainId, _name); } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.24; /// @title LibNetwork library 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; /// @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 an internal Taiko devnet's base layer. /// @param _chainId The chain ID. /// @return true if the chain ID represents an internal Taiko devnet's base layer, false /// otherwise. function isTaikoDevnetL1(uint256 _chainId) internal pure returns (bool) { return _chainId >= 32_300 && _chainId <= 32_400; } /// @dev Checks if the chain supports Dencun hardfork. Note that this check doesn't need to be /// exhaustive. /// @param _chainId The chain ID. /// @return true if the chain supports Dencun hardfork, false otherwise. function isDencunSupported(uint256 _chainId) internal pure returns (bool) { return _chainId == LibNetwork.MAINNET || _chainId == LibNetwork.HOLESKY || _chainId == LibNetwork.SEPOLIA || isTaikoDevnetL1(_chainId); } }
// 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 Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // 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. * * 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 == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } }
// 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 SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } }
// 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); }
// 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 1 bytes32 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; } /** * @dev Perform implementation upgrade * * Emits an {Upgraded} event. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Perform implementation upgrade with additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal { _upgradeTo(newImplementation); if (data.length > 0 || forceCall) { Address.functionDelegateCall(newImplementation, data); } } /** * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal { // Upgrades from old implementations will perform a rollback test. This test requires the new // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing // this special case will break upgrade paths from old UUPS implementation to new ones. if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) { _setImplementation(newImplementation); } else { try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) { require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID"); } catch { revert("ERC1967Upgrade: new implementation is not UUPS"); } _upgradeToAndCall(newImplementation, data, forceCall); } } /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Returns the current admin. */ function _getAdmin() internal view returns (address) { return StorageSlot.getAddressSlot(_ADMIN_SLOT).value; } /** * @dev Stores a new address in the EIP1967 admin slot. */ function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } /** * @dev Changes the admin of the proxy. * * Emits an {AdminChanged} event. */ function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. */ bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Returns the current beacon. */ function _getBeacon() internal view returns (address) { return StorageSlot.getAddressSlot(_BEACON_SLOT).value; } /** * @dev Stores a new beacon in the EIP1967 beacon slot. */ function _setBeacon(address newBeacon) private { require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require( Address.isContract(IBeacon(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract" ); StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon; } /** * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that). * * Emits a {BeaconUpgraded} event. */ function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); } } }
// 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(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } /** * @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[49] private __gap; }
// 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] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a * constructor. * * Emits an {Initialized} event. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: setting the version to 255 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized != type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } /** * @dev Returns the highest version that has been initialized. See {reinitializer}. */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}. */ function _isInitializing() internal view returns (bool) { return _initializing; } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.24; /// @title IAddressManager /// @notice Manages a mapping of (chainId, name) pairs to Ethereum addresses. /// @custom:security-contact [email protected] interface 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); }
// SPDX-License-Identifier: MIT pragma 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 [email protected] interface 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 ) external view returns (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 ) external view returns (address payable); }
// 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); }
// 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); }
// 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 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// 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; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } /** * @dev Returns an `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } }
// 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; }
// 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 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
{ "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/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "cancun", "viaIR": false, "libraries": {} }
[{"inputs":[],"name":"INVALID_PAUSE_STATUS","type":"error"},{"inputs":[],"name":"REENTRANT_CALL","type":"error"},{"inputs":[],"name":"RESOLVER_DENIED","type":"error"},{"inputs":[],"name":"RESOLVER_INVALID_MANAGER","type":"error"},{"inputs":[],"name":"RESOLVER_UNEXPECTED_CHAINID","type":"error"},{"inputs":[{"internalType":"uint64","name":"chainId","type":"uint64"},{"internalType":"bytes32","name":"name","type":"bytes32"}],"name":"RESOLVER_ZERO_ADDR","type":"error"},{"inputs":[],"name":"SGX_ALREADY_ATTESTED","type":"error"},{"inputs":[],"name":"SGX_INVALID_ATTESTATION","type":"error"},{"inputs":[],"name":"SGX_INVALID_INSTANCE","type":"error"},{"inputs":[],"name":"SGX_INVALID_PROOF","type":"error"},{"inputs":[],"name":"SGX_RA_NOT_SUPPORTED","type":"error"},{"inputs":[],"name":"ZERO_ADDR_MANAGER","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"instance","type":"address"},{"indexed":false,"internalType":"address","name":"replaced","type":"address"},{"indexed":false,"internalType":"uint256","name":"validSince","type":"uint256"}],"name":"InstanceAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"instance","type":"address"}],"name":"InstanceDeleted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"INSTANCE_EXPIRY","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INSTANCE_VALIDITY_DELAY","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_instances","type":"address[]"}],"name":"addInstances","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"addressManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"instanceAddress","type":"address"}],"name":"addressRegistered","outputs":[{"internalType":"bool","name":"alreadyAttested","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_ids","type":"uint256[]"}],"name":"deleteInstances","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_addressManager","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"instanceId","type":"uint256"}],"name":"instances","outputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"validSince","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUnpausedAt","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextInstanceId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"bytes2","name":"version","type":"bytes2"},{"internalType":"bytes2","name":"attestationKeyType","type":"bytes2"},{"internalType":"bytes4","name":"teeType","type":"bytes4"},{"internalType":"bytes2","name":"qeSvn","type":"bytes2"},{"internalType":"bytes2","name":"pceSvn","type":"bytes2"},{"internalType":"bytes16","name":"qeVendorId","type":"bytes16"},{"internalType":"bytes20","name":"userData","type":"bytes20"}],"internalType":"struct V3Struct.Header","name":"header","type":"tuple"},{"components":[{"internalType":"bytes16","name":"cpuSvn","type":"bytes16"},{"internalType":"bytes4","name":"miscSelect","type":"bytes4"},{"internalType":"bytes28","name":"reserved1","type":"bytes28"},{"internalType":"bytes16","name":"attributes","type":"bytes16"},{"internalType":"bytes32","name":"mrEnclave","type":"bytes32"},{"internalType":"bytes32","name":"reserved2","type":"bytes32"},{"internalType":"bytes32","name":"mrSigner","type":"bytes32"},{"internalType":"bytes","name":"reserved3","type":"bytes"},{"internalType":"uint16","name":"isvProdId","type":"uint16"},{"internalType":"uint16","name":"isvSvn","type":"uint16"},{"internalType":"bytes","name":"reserved4","type":"bytes"},{"internalType":"bytes","name":"reportData","type":"bytes"}],"internalType":"struct V3Struct.EnclaveReport","name":"localEnclaveReport","type":"tuple"},{"components":[{"internalType":"bytes","name":"ecdsa256BitSignature","type":"bytes"},{"internalType":"bytes","name":"ecdsaAttestationKey","type":"bytes"},{"components":[{"internalType":"bytes16","name":"cpuSvn","type":"bytes16"},{"internalType":"bytes4","name":"miscSelect","type":"bytes4"},{"internalType":"bytes28","name":"reserved1","type":"bytes28"},{"internalType":"bytes16","name":"attributes","type":"bytes16"},{"internalType":"bytes32","name":"mrEnclave","type":"bytes32"},{"internalType":"bytes32","name":"reserved2","type":"bytes32"},{"internalType":"bytes32","name":"mrSigner","type":"bytes32"},{"internalType":"bytes","name":"reserved3","type":"bytes"},{"internalType":"uint16","name":"isvProdId","type":"uint16"},{"internalType":"uint16","name":"isvSvn","type":"uint16"},{"internalType":"bytes","name":"reserved4","type":"bytes"},{"internalType":"bytes","name":"reportData","type":"bytes"}],"internalType":"struct V3Struct.EnclaveReport","name":"pckSignedQeReport","type":"tuple"},{"internalType":"bytes","name":"qeReportSignature","type":"bytes"},{"components":[{"internalType":"uint16","name":"parsedDataSize","type":"uint16"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct V3Struct.QEAuthData","name":"qeAuthData","type":"tuple"},{"components":[{"internalType":"uint16","name":"certType","type":"uint16"},{"internalType":"uint32","name":"certDataSize","type":"uint32"},{"internalType":"bytes[3]","name":"decodedCertDataArray","type":"bytes[3]"}],"internalType":"struct V3Struct.CertificationData","name":"certification","type":"tuple"}],"internalType":"struct V3Struct.ECDSAQuoteV3AuthData","name":"v3AuthData","type":"tuple"}],"internalType":"struct V3Struct.ParsedV3QuoteStruct","name":"_attestation","type":"tuple"}],"name":"registerInstance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_chainId","type":"uint64"},{"internalType":"bytes32","name":"_name","type":"bytes32"},{"internalType":"bool","name":"_allowZeroAddress","type":"bool"}],"name":"resolve","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_name","type":"bytes32"},{"internalType":"bool","name":"_allowZeroAddress","type":"bool"}],"name":"resolve","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"metaHash","type":"bytes32"},{"internalType":"bytes32","name":"blobHash","type":"bytes32"},{"internalType":"address","name":"prover","type":"address"},{"internalType":"uint64","name":"blockId","type":"uint64"},{"internalType":"bool","name":"isContesting","type":"bool"},{"internalType":"bool","name":"blobUsed","type":"bool"},{"internalType":"address","name":"msgSender","type":"address"}],"internalType":"struct IVerifier.Context","name":"_ctx","type":"tuple"},{"components":[{"internalType":"bytes32","name":"parentHash","type":"bytes32"},{"internalType":"bytes32","name":"blockHash","type":"bytes32"},{"internalType":"bytes32","name":"stateRoot","type":"bytes32"},{"internalType":"bytes32","name":"graffiti","type":"bytes32"}],"internalType":"struct TaikoData.Transition","name":"_tran","type":"tuple"},{"components":[{"internalType":"uint16","name":"tier","type":"uint16"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct TaikoData.TierProof","name":"_proof","type":"tuple"}],"name":"verifyProof","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
0x608060405260043610610161575f3560e01c80638456cb59116100cd578063b51ec32811610087578063e30c397811610062578063e30c397814610461578063ee45abb01461047e578063f09a401614610493578063f2fde38b146104b2575f80fd5b8063b51ec328146103fa578063d632cf3514610425578063e07baba61461043c575f80fd5b80638456cb59146102f05780638da5cb5b146103045780639d7809b514610321578063a2f7b3a51461034f578063a86f9d9e146103bc578063a91951a2146103db575f80fd5b80634ef36a561161011e5780634ef36a56146102445780634f1ef2861461026357806352d1902d146102765780635c975abb14610298578063715018a6146102c857806379ba5097146102dc575f80fd5b8063161072901461016557806321e899681461019a5780633659cfe6146101bb5780633ab76e9f146101da5780633eb6b8cf146102115780633f4ba83a14610230575b5f80fd5b348015610170575f80fd5b5061018461017f366004611cde565b6104d1565b6040516101919190611d1c565b60405180910390f35b3480156101a5575f80fd5b506101b96101b4366004611d5f565b610522565b005b3480156101c6575f80fd5b506101b96101d5366004611de4565b610743565b3480156101e5575f80fd5b506097546101f9906001600160a01b031681565b6040516001600160a01b039091168152602001610191565b34801561021c575f80fd5b506101f961022b366004611e27565b610829565b34801561023b575f80fd5b506101b961083d565b34801561024f575f80fd5b506101b961025e366004611cde565b6108d6565b6101b9610271366004611ec5565b610a1c565b348015610281575f80fd5b5061028a610aeb565b604051908152602001610191565b3480156102a3575f80fd5b506102b860c954610100900460ff1660021490565b6040519015158152602001610191565b3480156102d3575f80fd5b506101b9610b9c565b3480156102e7575f80fd5b506101b9610bad565b3480156102fb575f80fd5b506101b9610c24565b34801561030f575f80fd5b506033546001600160a01b03166101f9565b34801561032c575f80fd5b506102b861033b366004611de4565b60fd6020525f908152604090205460ff1681565b34801561035a575f80fd5b50610395610369366004611f51565b60fc6020525f90815260409020546001600160a01b03811690600160a01b90046001600160401b031682565b604080516001600160a01b0390931683526001600160401b03909116602083015201610191565b3480156103c7575f80fd5b506101f96103d6366004611f68565b610ca3565b3480156103e6575f80fd5b5061028a6103f5366004611f96565b610caf565b348015610405575f80fd5b5061040d5f81565b6040516001600160401b039091168152602001610191565b348015610430575f80fd5b5061040d6301e1338081565b348015610447575f80fd5b5060c95461040d906201000090046001600160401b031681565b34801561046c575f80fd5b506065546001600160a01b03166101f9565b348015610489575f80fd5b5061028a60fb5481565b34801561049e575f80fd5b506101b96104ad366004611fcd565b610e3e565b3480156104bd575f80fd5b506101b96104cc366004611de4565b610f4d565b60606104db610fbe565b6105198383808060200260200160405190810160405280939291908181526020018383602002808284375f9201919091525060019250611018915050565b90505b92915050565b647461696b6f60d81b610536816001610ca3565b6001600160a01b0316336001600160a01b03161461056757604051630d85cccf60e11b815260040160405180910390fd5b61057760a0850160808601611ff9565b61073d576105886020830183612014565b90506059146105aa57604051637bb2c12960e01b815260040160405180910390fd5b5f6105b86020840184612014565b6105c6916004915f91612056565b6105cf9161207d565b60e01c90505f6105e26020850185612014565b6105f191601891600491612056565b6105fa916120ab565b60601c90505f610612647461696b6f60d81b5f610ca3565b6001600160a01b031663c3f909d46040518163ffffffff1660e01b815260040160e060405180830381865afa15801561064d573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106719190612125565b5190505f6106f86106a461068a368a90038a018a6121da565b308661069c60608e0160408f01611de4565b8d35886112b8565b6106b16020890189612014565b6106bf916018908290612056565b8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152506112f692505050565b905061070a8463ffffffff1682611318565b61072757604051630c3bd7cd60e11b815260040160405180910390fd5b6107388463ffffffff1682856113be565b505050505b50505050565b6001600160a01b037f000000000000000000000000a41f15107ac6f18502e2181be8a9dd477087ceb11630036107945760405162461bcd60e51b815260040161078b9061223d565b60405180910390fd5b7f000000000000000000000000a41f15107ac6f18502e2181be8a9dd477087ceb16001600160a01b03166107dc5f80516020612a73833981519152546001600160a01b031690565b6001600160a01b0316146108025760405162461bcd60e51b815260040161078b90612289565b61080b8161145b565b604080515f8082526020820190925261082691839190611463565b50565b5f6108358484846115cd565b949350505050565b61085160c954610100900460ff1660021490565b61086e5760405163bae6e2a960e01b815260040160405180910390fd5b60c9805461010069ffffffffffffffffff001990911662010000426001600160401b031602171790556040513381527f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa9060200160405180910390a16108d4335f6116b6565b565b6e726f6c6c75705f7761746368646f6760881b6108fb6033546001600160a01b031690565b6001600160a01b0316336001600160a01b0316141580156109385750610922816001610ca3565b6001600160a01b0316336001600160a01b031614155b1561095657604051630d85cccf60e11b815260040160405180910390fd5b5f5b8281101561073d575f848483818110610973576109736122d5565b602090810292909201355f81815260fc909352604090922054919250506001600160a01b03166109b657604051630c3bd7cd60e11b815260040160405180910390fd5b5f81815260fc60205260408082205490516001600160a01b039091169183917f89d0dca869ffe08b709ca9ff5adfd5ee8d9de2750d0561e15df614c7a2596d8e9190a35f90815260fc6020526040902080546001600160e01b0319169055600101610958565b6001600160a01b037f000000000000000000000000a41f15107ac6f18502e2181be8a9dd477087ceb1163003610a645760405162461bcd60e51b815260040161078b9061223d565b7f000000000000000000000000a41f15107ac6f18502e2181be8a9dd477087ceb16001600160a01b0316610aac5f80516020612a73833981519152546001600160a01b031690565b6001600160a01b031614610ad25760405162461bcd60e51b815260040161078b90612289565b610adb8261145b565b610ae782826001611463565b5050565b5f306001600160a01b037f000000000000000000000000a41f15107ac6f18502e2181be8a9dd477087ceb11614610b8a5760405162461bcd60e51b815260206004820152603860248201527f555550535570677261646561626c653a206d757374206e6f742062652063616c60448201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000606482015260840161078b565b505f80516020612a7383398151915290565b610ba4610fbe565b6108d45f6116be565b60655433906001600160a01b03168114610c1b5760405162461bcd60e51b815260206004820152602960248201527f4f776e61626c6532537465703a2063616c6c6572206973206e6f7420746865206044820152683732bb9037bbb732b960b91b606482015260840161078b565b610826816116be565b610c3860c954610100900460ff1660021490565b15610c565760405163bae6e2a960e01b815260040160405180910390fd5b60c9805461ff0019166102001790556040513381527f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2589060200160405180910390a16108d43360016116b6565b5f6105194684846115cd565b5f80610cdc7f6175746f6d6174615f646361705f6174746573746174696f6e000000000000006001610ca3565b90506001600160a01b038116610d055760405163fd85d29d60e01b815260040160405180910390fd5b60405163089a168f60e01b81525f906001600160a01b0383169063089a168f90610d339087906004016126eb565b5f604051808303815f875af1158015610d4e573d5f803e3d5ffd5b505050506040513d5f823e601f3d908101601f19168201604052610d759190810190612804565b50905080610d9657604051631cbfe78f60e21b815260040160405180910390fd5b6040805160018082528183019092525f9160208083019080368337019050509050610dc460e086018661288b565b610dd390610160810190612014565b610ddc916120ab565b60601c815f81518110610df157610df16122d5565b60200260200101906001600160a01b031690816001600160a01b031681525050610e1b815f611018565b5f81518110610e2c57610e2c6122d5565b60200260200101519350505050919050565b5f54610100900460ff1615808015610e5c57505f54600160ff909116105b80610e755750303b158015610e7557505f5460ff166001145b610ed85760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b606482015260840161078b565b5f805460ff191660011790558015610ef9575f805461ff0019166101001790555b610f0383836116d7565b8015610f48575f805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b505050565b610f55610fbe565b606580546001600160a01b0383166001600160a01b03199091168117909155610f866033546001600160a01b031690565b6001600160a01b03167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e2270060405160405180910390a350565b6033546001600160a01b031633146108d45760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161078b565b606082516001600160401b0381111561103357611033611e5b565b60405190808252806020026020018201604052801561105c578160200160208202803683370190505b50905042826110725761106f5f826128be565b90505b5f5b84518110156112b05760fd5f868381518110611092576110926122d5565b6020908102919091018101516001600160a01b031682528101919091526040015f205460ff16156110d65760405163a239527960e01b815260040160405180910390fd5b600160fd5f8784815181106110ed576110ed6122d5565b60200260200101516001600160a01b03166001600160a01b031681526020019081526020015f205f6101000a81548160ff0219169083151502179055505f6001600160a01b0316858281518110611146576111466122d5565b60200260200101516001600160a01b03160361117557604051630c3bd7cd60e11b815260040160405180910390fd5b6040518060400160405280868381518110611192576111926122d5565b6020908102919091018101516001600160a01b0390811683526001600160401b038087169383019390935260fb80545f90815260fc845260409020855181549690940151909416600160a01b026001600160e01b0319909516929091169190911792909217905554835184908390811061120e5761120e6122d5565b60200260200101818152505084818151811061122c5761122c6122d5565b60200260200101516001600160a01b031660fb547fbbe529d240965181270c1e2e32a80761e8807dda1ee9765e326178bd6804a9cb5f8560405161128e9291906001600160a01b039290921682526001600160401b0316602082015260400190565b60405180910390a360fb5f81546112a4906128e5565b90915550600101611074565b505092915050565b5f8186888787876040516020016112d4969594939291906128fd565b6040516020818303038152906040528051906020012090509695505050505050565b5f805f6113038585611736565b9150915061131081611778565b509392505050565b5f6001600160a01b03821661132e57505f61051c565b5f83815260fc60205260409020546001600160a01b0383811691161461135557505f61051c565b5f83815260fc602052604090205442600160a01b9091046001600160401b03161180159061051957505f83815260fc60205260409020546113ab906301e1338090600160a01b90046001600160401b03166128be565b6001600160401b03164211159392505050565b6040805180820182526001600160a01b038381168083526001600160401b034281811660208087019182525f8b815260fc8252889020965187549251909416600160a01b026001600160e01b0319909216938616939093171790945584519287168352820192909252909185917fbbe529d240965181270c1e2e32a80761e8807dda1ee9765e326178bd6804a9cb910160405180910390a3505050565b610826610fbe565b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd91435460ff161561149657610f48836118c1565b826001600160a01b03166352d1902d6040518163ffffffff1660e01b8152600401602060405180830381865afa9250505080156114f0575060408051601f3d908101601f191682019092526114ed9181019061299e565b60015b6115535760405162461bcd60e51b815260206004820152602e60248201527f45524331393637557067726164653a206e657720696d706c656d656e7461746960448201526d6f6e206973206e6f74205555505360901b606482015260840161078b565b5f80516020612a7383398151915281146115c15760405162461bcd60e51b815260206004820152602960248201527f45524331393637557067726164653a20756e737570706f727465642070726f786044820152681a58589b195555525160ba1b606482015260840161078b565b50610f4883838361195c565b6097545f906001600160a01b0316806115f957604051638ed88b2560e01b815260040160405180910390fd5b604051630a3dc4f360e21b81526001600160401b0386166004820152602481018590526001600160a01b038216906328f713cc90604401602060405180830381865afa15801561164b573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061166f91906129b5565b91508215801561168657506001600160a01b038216155b1561131057604051632b0d65db60e01b81526001600160401b03861660048201526024810185905260440161078b565b610ae7610fbe565b606580546001600160a01b031916905561082681611980565b5f54610100900460ff166116fd5760405162461bcd60e51b815260040161078b906129d0565b6001600160a01b038116611724576040516375cabfef60e11b815260040160405180910390fd5b61172d826119d1565b610ae781611a01565b5f80825160410361176a576020830151604084015160608501515f1a61175e87828585611a71565b94509450505050611771565b505f905060025b9250929050565b5f81600481111561178b5761178b612a1b565b036117935750565b60018160048111156117a7576117a7612a1b565b036117f45760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e61747572650000000000000000604482015260640161078b565b600281600481111561180857611808612a1b565b036118555760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e67746800604482015260640161078b565b600381600481111561186957611869612a1b565b036108265760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b606482015260840161078b565b6001600160a01b0381163b61192e5760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b606482015260840161078b565b5f80516020612a7383398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b61196583611b2e565b5f825111806119715750805b15610f485761073d8383611b6d565b603380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b6119ef6001600160a01b038216156119e957816116be565b336116be565b5060c9805461ff001916610100179055565b5f54610100900460ff16611a275760405162461bcd60e51b815260040161078b906129d0565b6001600160401b03461115611a4f5760405163a12e8fa960e01b815260040160405180910390fd5b609780546001600160a01b0319166001600160a01b0392909216919091179055565b5f807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115611aa657505f90506003611b25565b604080515f8082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015611af7573d5f803e3d5ffd5b5050604051601f1901519150506001600160a01b038116611b1f575f60019250925050611b25565b91505f90505b94509492505050565b611b37816118c1565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b905f90a250565b60606105198383604051806060016040528060278152602001612a936027913960605f80856001600160a01b031685604051611ba99190612a2f565b5f60405180830381855af49150503d805f8114611be1576040519150601f19603f3d011682016040523d82523d5f602084013e611be6565b606091505b5091509150611bf786838387611c01565b9695505050505050565b60608315611c6f5782515f03611c68576001600160a01b0385163b611c685760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161078b565b5081610835565b6108358383815115611c845781518083602001fd5b8060405162461bcd60e51b815260040161078b9190612a40565b5f8083601f840112611cae575f80fd5b5081356001600160401b03811115611cc4575f80fd5b6020830191508360208260051b8501011115611771575f80fd5b5f8060208385031215611cef575f80fd5b82356001600160401b03811115611d04575f80fd5b611d1085828601611c9e565b90969095509350505050565b602080825282518282018190525f9190848201906040850190845b81811015611d5357835183529284019291840191600101611d37565b50909695505050505050565b5f805f838503610180811215611d73575f80fd5b60e0811215611d80575f80fd5b849350608060df1982011215611d94575f80fd5b5060e0840191506101608401356001600160401b03811115611db4575f80fd5b840160408187031215611dc5575f80fd5b809150509250925092565b6001600160a01b0381168114610826575f80fd5b5f60208284031215611df4575f80fd5b8135611dff81611dd0565b9392505050565b6001600160401b0381168114610826575f80fd5b8015158114610826575f80fd5b5f805f60608486031215611e39575f80fd5b8335611e4481611e06565b9250602084013591506040840135611dc581611e1a565b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f191681016001600160401b0381118282101715611e9757611e97611e5b565b604052919050565b5f6001600160401b03821115611eb757611eb7611e5b565b50601f01601f191660200190565b5f8060408385031215611ed6575f80fd5b8235611ee181611dd0565b915060208301356001600160401b03811115611efb575f80fd5b8301601f81018513611f0b575f80fd5b8035611f1e611f1982611e9f565b611e6f565b818152866020838501011115611f32575f80fd5b816020840160208301375f602083830101528093505050509250929050565b5f60208284031215611f61575f80fd5b5035919050565b5f8060408385031215611f79575f80fd5b823591506020830135611f8b81611e1a565b809150509250929050565b5f60208284031215611fa6575f80fd5b81356001600160401b03811115611fbb575f80fd5b82016101208185031215611dff575f80fd5b5f8060408385031215611fde575f80fd5b8235611fe981611dd0565b91506020830135611f8b81611dd0565b5f60208284031215612009575f80fd5b8135611dff81611e1a565b5f808335601e19843603018112612029575f80fd5b8301803591506001600160401b03821115612042575f80fd5b602001915036819003821315611771575f80fd5b5f8085851115612064575f80fd5b83861115612070575f80fd5b5050820193919092039150565b6001600160e01b031981358181169160048510156112b05760049490940360031b84901b1690921692915050565b6001600160601b031981358181169160148510156112b05760149490940360031b84901b1690921692915050565b63ffffffff81168114610826575f80fd5b80516120f5816120d9565b919050565b80516bffffffffffffffffffffffff811681146120f5575f80fd5b805160ff811681146120f5575f80fd5b5f60e08284031215612135575f80fd5b60405160e081018181106001600160401b038211171561215757612157611e5b565b604052825161216581611e06565b8152602083015161217581611e06565b6020820152604083015161218881611e06565b6040820152606083015161219b81611e06565b60608201526121ac608084016120ea565b60808201526121bd60a084016120fa565b60a08201526121ce60c08401612115565b60c08201529392505050565b5f608082840312156121ea575f80fd5b604051608081018181106001600160401b038211171561220c5761220c611e5b565b8060405250823581526020830135602082015260408301356040820152606083013560608201528091505092915050565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b19195b1959d85d1958d85b1b60a21b606082015260800190565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b6163746976652070726f787960a01b606082015260800190565b634e487b7160e01b5f52603260045260245ffd5b80356001600160f01b0319811681146120f5575f80fd5b80356001600160e01b0319811681146120f5575f80fd5b80356001600160801b0319811681146120f5575f80fd5b80356001600160601b0319811681146120f5575f80fd5b5f823561017e1983360301811261235a575f80fd5b90910192915050565b803563ffffffff19811681146120f5575f80fd5b5f808335601e1984360301811261238c575f80fd5b83016020810192503590506001600160401b038111156123aa575f80fd5b803603821315611771575f80fd5b81835281816020850137505f828201602090810191909152601f909101601f19169091010190565b803561ffff811681146120f5575f80fd5b5f6101806124108461240285612317565b6001600160801b0319169052565b61241c60208401612300565b6001600160e01b031916602085015261243760408401612363565b63ffffffff1916604085015261244f60608401612317565b6001600160801b031981166060860152506080830135608085015260a083013560a085015260c083013560c085015261248b60e0840184612377565b8260e087015261249e83870182846123b8565b925050506101006124b08185016123e0565b61ffff16908501526101206124c68482016123e0565b61ffff16908501526101406124dd84820185612377565b868403838801526124ef8482846123b8565b935050505061016061250381850185612377565b868403838801526125158482846123b8565b979650505050505050565b5f823560be1983360301811261235a575f80fd5b61ffff612540826123e0565b1682525f6125516020830183612377565b604060208601526125666040860182846123b8565b95945050505050565b5f8235605e1983360301811261235a575f80fd5b5f6060830161ffff612594846123e0565b1684526020808401356125a6816120d9565b63ffffffff1660208601526125be604085018561256f565b6060604087015260c0860192815f5b600381101561260857888603605f190183526125e98285612377565b6125f48882846123b8565b9750505091840191908401906001016125cd565b5093979650505050505050565b5f6126208283612377565b60c0855261263260c0860182846123b8565b9150506126426020840184612377565b85830360208701526126558382846123b8565b925050506126666040840184612345565b848203604086015261267882826123f1565b9150506126886060840184612377565b858303606087015261269b8382846123b8565b925050506080830135603e198436030181126126b5575f80fd5b84820360808601526126c982858301612534565b9150506126d960a084018461256f565b84820360a08601526125668282612583565b602081525f6001600160f01b031980612703856122e9565b16602084015280612716602086016122e9565b16604084015263ffffffff60e01b61273060408601612300565b16606084015280612743606086016122e9565b16608084015280612756608086016122e9565b1660a08401525061276960a08401612317565b6001600160801b0319811660c08401525061278660c0840161232e565b6001600160601b0319811660e0840152506127a460e0840184612345565b61012061010081818601526127bd6101408601846123f1565b92506127cb81870187612520565b858403601f1901838701529050611bf78382612615565b5f5b838110156127fc5781810151838201526020016127e4565b50505f910152565b5f8060408385031215612815575f80fd5b825161282081611e1a565b60208401519092506001600160401b0381111561283b575f80fd5b8301601f8101851361284b575f80fd5b8051612859611f1982611e9f565b81815286602083850101111561286d575f80fd5b61287e8260208301602086016127e2565b8093505050509250929050565b5f823561017e198336030181126128a0575f80fd5b9190910192915050565b634e487b7160e01b5f52601160045260245ffd5b6001600160401b038181168382160190808211156128de576128de6128aa565b5092915050565b5f600182016128f6576128f66128aa565b5060010190565b5f610140808352600c81840152506b2b22a924a32cafa82927a7a360a11b610160830152610180820190506001600160401b038816602083015260018060a01b03871660408301528551606083015260208601516080830152604086015160a0830152606086015160c083015261297f60e08301866001600160a01b03169052565b6001600160a01b03939093166101008201526101200152949350505050565b5f602082840312156129ae575f80fd5b5051919050565b5f602082840312156129c5575f80fd5b8151611dff81611dd0565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b634e487b7160e01b5f52602160045260245ffd5b5f82516128a08184602087016127e2565b602081525f8251806020840152612a5e8160408501602087016127e2565b601f01601f1916919091016040019291505056fe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220d45fa90ccaeed27ff2cef67be271f1cac864066b4989a299f01ce6c5b7673f3a64736f6c63430008180033
Loading...
Loading
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.