Warning! Contract bytecode has been changed and doesn't match the verified one. Therefore, interaction with this smart contract may be risky.
- Contract name:
- SignalService
- Optimization enabled
- true
- Compiler version
- v0.8.27+commit.40a35a09
- Optimization runs
- 200
- EVM Version
- shanghai
- Verified at
- 2025-03-24T01:57:39.222332Z
Constructor Arguments
0x0000000000000000000000001670090000000000000000000000000000000006
Arg [0] (address) : 0x1670090000000000000000000000000000000006
contracts/shared/signal/SignalService.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "../common/EssentialContract.sol";
import "../libs/LibStrings.sol";
import "../libs/LibTrieProof.sol";
import "./ISignalService.sol";
/// @title SignalService
/// @notice See the documentation in {ISignalService} for more details.
/// @dev Labeled in address resolver as "signal_service".
/// @custom:security-contact security@taiko.xyz
contract SignalService is EssentialContract, ISignalService {
/// @notice Mapping to store the top blockId.
/// @dev Slot 1.
mapping(uint64 chainId => mapping(bytes32 kind => uint64 blockId)) public topBlockId;
/// @notice Mapping to store the authorized addresses.
/// @dev Slot 2.
mapping(address addr => bool authorized) public isAuthorized;
mapping(bytes32 signalSlot => bool received) internal _receivedSignals;
uint256[47] private __gap;
struct CacheAction {
bytes32 rootHash;
bytes32 signalRoot;
uint64 chainId;
uint64 blockId;
bool isFullProof;
bool isLastHop;
CacheOption option;
}
error SS_EMPTY_PROOF();
error SS_INVALID_HOPS_WITH_LOOP();
error SS_INVALID_LAST_HOP_CHAINID();
error SS_INVALID_MID_HOP_CHAINID();
error SS_INVALID_STATE();
error SS_SIGNAL_NOT_FOUND();
error SS_SIGNAL_NOT_RECEIVED();
error SS_UNAUTHORIZED();
constructor(address _resolver) EssentialContract(_resolver) { }
/// @notice Initializes the contract.
/// @param _owner The owner of this contract. msg.sender will be used if this value is zero.
function init(address _owner) external initializer {
__Essential_init(_owner);
}
/// @dev Authorize or deauthorize an address for calling syncChainData.
/// @dev Note that addr is supposed to be Taiko and Taiko contracts deployed locally.
/// @param _addr The address to be authorized or deauthorized.
/// @param _authorize True if authorize, false otherwise.
function authorize(address _addr, bool _authorize) external onlyOwner {
if (isAuthorized[_addr] == _authorize) revert SS_INVALID_STATE();
isAuthorized[_addr] = _authorize;
emit Authorized(_addr, _authorize);
}
/// @dev Allow TaikoL2 to receive signals directly in its Anchor transaction.
/// @param _signalSlots The signal slots to mark as received.
function receiveSignals(bytes32[] calldata _signalSlots)
external
onlyFromNamed(LibStrings.B_TAIKO)
{
for (uint256 i; i < _signalSlots.length; ++i) {
_receivedSignals[_signalSlots[i]] = true;
}
emit SignalsReceived(_signalSlots);
}
/// @inheritdoc ISignalService
function sendSignal(bytes32 _signal) external returns (bytes32) {
return _sendSignal(msg.sender, _signal, _signal);
}
/// @inheritdoc ISignalService
function syncChainData(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId,
bytes32 _chainData
)
external
returns (bytes32)
{
if (!isAuthorized[msg.sender]) revert SS_UNAUTHORIZED();
return _syncChainData(_chainId, _kind, _blockId, _chainData);
}
/// @inheritdoc ISignalService
/// @dev This function may revert.
function proveSignalReceived(
uint64 _chainId,
address _app,
bytes32 _signal,
bytes calldata _proof
)
external
virtual
whenNotPaused
nonReentrant
returns (uint256 numCacheOps_)
{
CacheAction[] memory actions = // actions for caching
_verifySignalReceived(_chainId, _app, _signal, _proof, true);
for (uint256 i; i < actions.length; ++i) {
numCacheOps_ += _cache(actions[i]);
}
}
/// @inheritdoc ISignalService
/// @dev This function may revert.
function verifySignalReceived(
uint64 _chainId,
address _app,
bytes32 _signal,
bytes calldata _proof
)
external
view
{
_verifySignalReceived(_chainId, _app, _signal, _proof, false);
}
/// @inheritdoc ISignalService
function isChainDataSynced(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId,
bytes32 _chainData
)
public
view
nonZeroBytes32(_chainData)
returns (bool)
{
bytes32 signal = signalForChainData(_chainId, _kind, _blockId);
return _loadSignalValue(address(this), signal) == _chainData;
}
/// @inheritdoc ISignalService
function isSignalSent(address _app, bytes32 _signal) public view returns (bool) {
return _loadSignalValue(_app, _signal) != 0;
}
/// @inheritdoc ISignalService
function isSignalSent(bytes32 _signalSlot) public view returns (bool) {
return _loadSignalValue(_signalSlot) != 0;
}
/// @inheritdoc ISignalService
function getSyncedChainData(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId
)
public
view
returns (uint64 blockId_, bytes32 chainData_)
{
blockId_ = _blockId != 0 ? _blockId : topBlockId[_chainId][_kind];
if (blockId_ != 0) {
bytes32 signal = signalForChainData(_chainId, _kind, blockId_);
chainData_ = _loadSignalValue(address(this), signal);
if (chainData_ == 0) revert SS_SIGNAL_NOT_FOUND();
}
}
/// @inheritdoc ISignalService
function signalForChainData(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId
)
public
pure
returns (bytes32)
{
return keccak256(abi.encode(_chainId, _kind, _blockId));
}
/// @notice Returns the slot for a signal.
/// @param _chainId The chainId of the signal.
/// @param _app The address that initiated the signal.
/// @param _signal The signal (message) that was sent.
/// @return The slot for the signal.
function getSignalSlot(
uint64 _chainId,
address _app,
bytes32 _signal
)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked("SIGNAL", _chainId, _app, _signal));
}
function _verifyHopProof(
uint64 _chainId,
address _app,
bytes32 _signal,
bytes32 _value,
HopProof memory _hop,
address _signalService
)
internal
view
virtual
nonZeroAddr(_app)
nonZeroBytes32(_signal)
nonZeroBytes32(_value)
returns (bytes32)
{
return LibTrieProof.verifyMerkleProof(
_hop.rootHash,
_signalService,
getSignalSlot(_chainId, _app, _signal),
_value,
_hop.accountProof,
_hop.storageProof
);
}
function _authorizePause(address, bool) internal pure override notImplemented { }
function _syncChainData(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId,
bytes32 _chainData
)
private
returns (bytes32 signal_)
{
signal_ = signalForChainData(_chainId, _kind, _blockId);
_sendSignal(address(this), signal_, _chainData);
if (topBlockId[_chainId][_kind] < _blockId) {
topBlockId[_chainId][_kind] = _blockId;
}
emit ChainDataSynced(_chainId, _blockId, _kind, _chainData, signal_);
}
function _sendSignal(
address _app,
bytes32 _signal,
bytes32 _value
)
private
nonZeroAddr(_app)
nonZeroBytes32(_signal)
nonZeroBytes32(_value)
returns (bytes32 slot_)
{
slot_ = getSignalSlot(uint64(block.chainid), _app, _signal);
assembly {
sstore(slot_, _value)
}
emit SignalSent(_app, _signal, slot_, _value);
}
function _cache(CacheAction memory _action) private returns (uint256 numCacheOps_) {
// cache state root
bool cacheStateRoot = _action.option == CacheOption.CACHE_BOTH
|| _action.option == CacheOption.CACHE_STATE_ROOT;
if (cacheStateRoot && _action.isFullProof && !_action.isLastHop) {
numCacheOps_ = 1;
_syncChainData(
_action.chainId, LibStrings.H_STATE_ROOT, _action.blockId, _action.rootHash
);
}
// cache signal root
bool cacheSignalRoot = _action.option == CacheOption.CACHE_BOTH
|| _action.option == CacheOption.CACHE_SIGNAL_ROOT;
if (cacheSignalRoot && (_action.isFullProof || !_action.isLastHop)) {
numCacheOps_ += 1;
_syncChainData(
_action.chainId, LibStrings.H_SIGNAL_ROOT, _action.blockId, _action.signalRoot
);
}
}
function _loadSignalValue(
address _app,
bytes32 _signal
)
private
view
nonZeroAddr(_app)
nonZeroBytes32(_signal)
returns (bytes32)
{
bytes32 slot = getSignalSlot(uint64(block.chainid), _app, _signal);
return _loadSignalValue(slot);
}
function _loadSignalValue(bytes32 _signalSlot) private view returns (bytes32 value_) {
assembly {
value_ := sload(_signalSlot)
}
}
function _verifySignalReceived(
uint64 _chainId,
address _app,
bytes32 _signal,
bytes calldata _proof,
bool _prepareCaching
)
private
view
nonZeroAddr(_app)
nonZeroBytes32(_signal)
returns (CacheAction[] memory actions)
{
if (_proof.length == 0) {
require(
_receivedSignals[getSignalSlot(_chainId, _app, _signal)], SS_SIGNAL_NOT_RECEIVED()
);
return new CacheAction[](0);
}
HopProof[] memory hopProofs = abi.decode(_proof, (HopProof[]));
if (hopProofs.length == 0) revert SS_EMPTY_PROOF();
uint64[] memory trace = new uint64[](hopProofs.length - 1);
actions = new CacheAction[](_prepareCaching ? hopProofs.length : 0);
uint64 chainId = _chainId;
address app = _app;
bytes32 signal = _signal;
bytes32 value = _signal;
address signalService = resolve(chainId, LibStrings.B_SIGNAL_SERVICE, false);
if (signalService == address(this)) revert SS_INVALID_MID_HOP_CHAINID();
HopProof memory hop;
bytes32 signalRoot;
bool isFullProof;
bool isLastHop;
for (uint256 i; i < hopProofs.length; ++i) {
hop = hopProofs[i];
for (uint256 j; j < i; ++j) {
if (trace[j] == hop.chainId) revert SS_INVALID_HOPS_WITH_LOOP();
}
signalRoot = _verifyHopProof(chainId, app, signal, value, hop, signalService);
isLastHop = i == trace.length;
if (isLastHop) {
if (hop.chainId != block.chainid) revert SS_INVALID_LAST_HOP_CHAINID();
signalService = address(this);
} else {
trace[i] = hop.chainId;
if (hop.chainId == 0 || hop.chainId == block.chainid) {
revert SS_INVALID_MID_HOP_CHAINID();
}
signalService = resolve(hop.chainId, LibStrings.B_SIGNAL_SERVICE, false);
if (signalService == address(this)) revert SS_INVALID_MID_HOP_CHAINID();
}
isFullProof = hop.accountProof.length != 0;
if (_prepareCaching) {
actions[i] = CacheAction(
hop.rootHash,
signalRoot,
chainId,
hop.blockId,
isFullProof,
isLastHop,
hop.cacheOption
);
}
signal = signalForChainData(
chainId,
isFullProof ? LibStrings.H_STATE_ROOT : LibStrings.H_SIGNAL_ROOT,
hop.blockId
);
value = hop.rootHash;
chainId = hop.chainId;
app = signalService;
}
if (value == 0 || value != _loadSignalValue(address(this), signal)) {
revert SS_SIGNAL_NOT_FOUND();
}
}
}
contracts/shared/common/EssentialContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import "./IResolver.sol";
/// @title EssentialContract
/// @custom:security-contact security@taiko.xyz
abstract contract EssentialContract is UUPSUpgradeable, Ownable2StepUpgradeable {
uint8 internal constant _FALSE = 1;
uint8 internal constant _TRUE = 2;
address private immutable __resolver;
uint256[50] private __gapFromOldAddressResolver;
/// @dev Slot 1.
uint8 internal __reentry;
uint8 internal __paused;
uint256[49] private __gap;
/// @notice Emitted when the contract is paused.
/// @param account The account that paused the contract.
event Paused(address account);
/// @notice Emitted when the contract is unpaused.
/// @param account The account that unpaused the contract.
event Unpaused(address account);
error INVALID_PAUSE_STATUS();
error FUNC_NOT_IMPLEMENTED();
error REENTRANT_CALL();
error ACCESS_DENIED();
error RESOLVER_NOT_FOUND();
error ZERO_ADDRESS();
error ZERO_VALUE();
/// @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) {
require(msg.sender == owner() || msg.sender == resolve(_name, true), ACCESS_DENIED());
_;
}
/// @dev Modifier that ensures the caller is either the owner or a specified address.
/// @param _addr The address to check against.
modifier onlyFromOwnerOr(address _addr) {
require(msg.sender == owner() || msg.sender == _addr, ACCESS_DENIED());
_;
}
/// @dev Modifier that reverts the function call, indicating it is not implemented.
modifier notImplemented() {
revert FUNC_NOT_IMPLEMENTED();
_;
}
/// @dev Modifier that prevents reentrant calls to a function.
modifier nonReentrant() {
require(_loadReentryLock() != _TRUE, REENTRANT_CALL());
_storeReentryLock(_TRUE);
_;
_storeReentryLock(_FALSE);
}
/// @dev Modifier that allows function execution only when the contract is paused.
modifier whenPaused() {
require(paused(), INVALID_PAUSE_STATUS());
_;
}
/// @dev Modifier that allows function execution only when the contract is not paused.
modifier whenNotPaused() {
require(!paused(), INVALID_PAUSE_STATUS());
_;
}
/// @dev Modifier that ensures the provided address is not the zero address.
/// @param _addr The address to check.
modifier nonZeroAddr(address _addr) {
require(_addr != address(0), ZERO_ADDRESS());
_;
}
/// @dev Modifier that ensures the provided value is not zero.
/// @param _value The value to check.
modifier nonZeroValue(uint256 _value) {
require(_value != 0, ZERO_VALUE());
_;
}
/// @dev Modifier that ensures the provided bytes32 value is not zero.
/// @param _value The bytes32 value to check.
modifier nonZeroBytes32(bytes32 _value) {
require(_value != 0, ZERO_VALUE());
_;
}
/// @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) {
require(msg.sender == resolve(_name, true), ACCESS_DENIED());
_;
}
/// @dev Modifier that ensures the caller is the resolved address of a given
/// name, if the name is set.
/// @param _name The name to check against.
modifier onlyFromOptionalNamed(bytes32 _name) {
address addr = resolve(_name, true);
require(addr == address(0) || msg.sender == addr, ACCESS_DENIED());
_;
}
/// @dev Modifier that ensures the caller is a resolved address to either _name1 or _name2
/// name.
/// @param _name1 The first name to check against.
/// @param _name2 The second name to check against.
modifier onlyFromNamedEither(bytes32 _name1, bytes32 _name2) {
require(
msg.sender == resolve(_name1, true) || msg.sender == resolve(_name2, true),
ACCESS_DENIED()
);
_;
}
/// @dev Modifier that ensures the caller is either of the two specified addresses.
/// @param _addr1 The first address to check against.
/// @param _addr2 The second address to check against.
modifier onlyFromEither(address _addr1, address _addr2) {
require(msg.sender == _addr1 || msg.sender == _addr2, ACCESS_DENIED());
_;
}
/// @dev Modifier that ensures the caller is the specified address.
/// @param _addr The address to check against.
modifier onlyFrom(address _addr) {
require(msg.sender == _addr, ACCESS_DENIED());
_;
}
/// @dev Modifier that ensures the caller is the specified address.
/// @param _addr The address to check against.
modifier onlyFromOptional(address _addr) {
require(_addr == address(0) || msg.sender == _addr, ACCESS_DENIED());
_;
}
constructor(address _resolver) {
__resolver = _resolver;
_disableInitializers();
}
/// @notice Pauses the contract.
function pause() public whenNotPaused {
_pause();
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 whenPaused {
_unpause();
emit Unpaused(msg.sender);
// We call the authorize function here to avoid:
// Warning (5740): Unreachable code.
_authorizePause(msg.sender, false);
}
function impl() public view returns (address) {
return _getImplementation();
}
/// @notice Returns true if the contract is paused, and false otherwise.
/// @return true if paused, false otherwise.
function paused() public view virtual returns (bool) {
return __paused == _TRUE;
}
function inNonReentrant() public view returns (bool) {
return _loadReentryLock() == _TRUE;
}
/// @notice Returns the address of this contract.
/// @return The address of this contract.
function resolver() public view virtual returns (address) {
return __resolver;
}
/// @notice Resolves a name to an address on a specific chain
/// @param _chainId The chain ID to resolve the name on
/// @param _name The name to resolve
/// @param _allowZeroAddress Whether to allow resolving to the zero address
/// @return The resolved address
function resolve(
uint64 _chainId,
bytes32 _name,
bool _allowZeroAddress
)
internal
view
returns (address)
{
return IResolver(resolver()).resolve(_chainId, _name, _allowZeroAddress);
}
/// @notice Resolves a name to an address on the current chain
/// @param _name The name to resolve
/// @param _allowZeroAddress Whether to allow resolving to the zero address
/// @return The resolved address
function resolve(bytes32 _name, bool _allowZeroAddress) internal view returns (address) {
return IResolver(resolver()).resolve(block.chainid, _name, _allowZeroAddress);
}
/// @notice Initializes the contract.
/// @param _owner The owner of this contract. msg.sender will be used if this value is zero.
function __Essential_init(address _owner) internal virtual onlyInitializing {
__Context_init();
_transferOwnership(_owner == address(0) ? msg.sender : _owner);
__paused = _FALSE;
}
function _pause() internal virtual {
__paused = _TRUE;
}
function _unpause() internal virtual {
__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 {
__reentry = _reentry;
}
// Loads the reentry lock
function _loadReentryLock() internal view virtual returns (uint8 reentry_) {
reentry_ = __reentry;
}
}
contracts/shared/common/IResolver.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/// @title IResolver
/// @notice This contract acts as a bridge for name-to-address resolution.
/// @custom:security-contact security@taiko.xyz
interface IResolver {
error RESOLVED_TO_ZERO_ADDRESS();
/// @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(
uint256 _chainId,
bytes32 _name,
bool _allowZeroAddress
)
external
view
returns (address);
}
contracts/shared/libs/LibStrings.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/// @title LibStrings
/// @custom:security-contact security@taiko.xyz
library LibStrings {
bytes32 internal constant B_AUTOMATA_DCAP_ATTESTATION = bytes32("automata_dcap_attestation");
bytes32 internal constant B_BOND_TOKEN = bytes32("bond_token");
bytes32 internal constant B_BRIDGE = bytes32("bridge");
bytes32 internal constant B_BRIDGE_WATCHDOG = bytes32("bridge_watchdog");
bytes32 internal constant B_BRIDGED_ERC1155 = bytes32("bridged_erc1155");
bytes32 internal constant B_BRIDGED_ERC20 = bytes32("bridged_erc20");
bytes32 internal constant B_BRIDGED_ERC721 = bytes32("bridged_erc721");
bytes32 internal constant B_CHAIN_WATCHDOG = bytes32("chain_watchdog");
bytes32 internal constant B_ERC1155_VAULT = bytes32("erc1155_vault");
bytes32 internal constant B_ERC20_VAULT = bytes32("erc20_vault");
bytes32 internal constant B_ERC721_VAULT = bytes32("erc721_vault");
bytes32 internal constant B_FORCED_INCLUSION_STORE = bytes32("forced_inclusion_store");
bytes32 internal constant B_PRECONF_WHITELIST = bytes32("preconf_whitelist");
bytes32 internal constant B_PRECONF_WHITELIST_OWNER = bytes32("preconf_whitelist_owner");
bytes32 internal constant B_PROOF_VERIFIER = bytes32("proof_verifier");
bytes32 internal constant B_PROVER_SET = bytes32("prover_set");
bytes32 internal constant B_QUOTA_MANAGER = bytes32("quota_manager");
bytes32 internal constant B_SGX_WATCHDOG = bytes32("sgx_watchdog");
bytes32 internal constant B_SIGNAL_SERVICE = bytes32("signal_service");
bytes32 internal constant B_TAIKO = bytes32("taiko");
bytes32 internal constant B_TAIKO_TOKEN = bytes32("taiko_token");
bytes32 internal constant B_WITHDRAWER = bytes32("withdrawer");
bytes32 internal constant H_SIGNAL_ROOT = keccak256("SIGNAL_ROOT");
bytes32 internal constant H_STATE_ROOT = keccak256("STATE_ROOT");
}
contracts/shared/libs/LibTrieProof.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "@optimism/packages/contracts-bedrock/src/libraries/rlp/RLPReader.sol";
import "@optimism/packages/contracts-bedrock/src/libraries/rlp/RLPWriter.sol";
import "@optimism/packages/contracts-bedrock/src/libraries/trie/SecureMerkleTrie.sol";
/// @title LibTrieProof
/// @custom:security-contact security@taiko.xyz
library LibTrieProof {
// The consensus format representing account is RLP encoded in the
// following order: nonce, balance, storageHash, codeHash.
uint256 private constant _ACCOUNT_FIELD_INDEX_STORAGE_HASH = 2;
error LTP_INVALID_ACCOUNT_PROOF();
error LTP_INVALID_INCLUSION_PROOF();
/// @notice Verifies that the value of a slot in the storage of an account is value.
///
/// @param _rootHash The merkle root of state tree or the account tree. If accountProof's length
/// is zero, it is used as the account's storage root, otherwise it will be used as the state
/// root.
/// @param _addr The address of contract.
/// @param _slot The slot in the contract.
/// @param _value The value to be verified.
/// @param _accountProof The account proof
/// @param _storageProof The storage proof
/// @return storageRoot_ The account's storage root
function verifyMerkleProof(
bytes32 _rootHash,
address _addr,
bytes32 _slot,
bytes32 _value,
bytes[] memory _accountProof,
bytes[] memory _storageProof
)
internal
pure
returns (bytes32 storageRoot_)
{
if (_accountProof.length != 0) {
bytes memory rlpAccount =
SecureMerkleTrie.get(abi.encodePacked(_addr), _accountProof, _rootHash);
require(rlpAccount.length != 0, LTP_INVALID_ACCOUNT_PROOF());
RLPReader.RLPItem[] memory accountState = RLPReader.readList(rlpAccount);
storageRoot_ =
bytes32(RLPReader.readBytes(accountState[_ACCOUNT_FIELD_INDEX_STORAGE_HASH]));
} else {
storageRoot_ = _rootHash;
}
bool verified = SecureMerkleTrie.verifyInclusionProof(
bytes.concat(_slot), RLPWriter.writeUint(uint256(_value)), _storageProof, storageRoot_
);
require(verified, LTP_INVALID_INCLUSION_PROOF());
}
}
contracts/shared/signal/ISignalService.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/// @title ISignalService
/// @notice The SignalService contract serves as a secure cross-chain message
/// passing system. It defines methods for sending and verifying signals with
/// merkle proofs. The trust assumption is that the target chain has secure
/// access to the merkle root (such as Taiko injects it in the anchor
/// transaction). With this, verifying a signal is reduced to simply verifying
/// a merkle proof.
/// @custom:security-contact security@taiko.xyz
interface ISignalService {
enum CacheOption {
CACHE_NOTHING,
CACHE_SIGNAL_ROOT,
CACHE_STATE_ROOT,
CACHE_BOTH
}
struct HopProof {
/// @notice This hop's destination chain ID. If there is a next hop, this ID is the next
/// hop's source chain ID.
uint64 chainId;
/// @notice The ID of a source chain block whose state root has been synced to the hop's
/// destination chain.
/// Note that this block ID must be greater than or equal to the block ID where the signal
/// was sent on the source chain.
uint64 blockId;
/// @notice The state root or signal root of the source chain at the above blockId. This
/// value has been synced to the destination chain.
/// @dev To get both the blockId and the rootHash, apps should subscribe to the
/// ChainDataSynced event or query `topBlockId` first using the source chain's ID and
/// LibStrings.H_STATE_ROOT to get the most recent block ID synced, then call
/// `getSyncedChainData` to read the synchronized data.
bytes32 rootHash;
/// @notice Options to cache either the state roots or signal roots of middle-hops to the
/// current chain.
CacheOption cacheOption;
/// @notice The signal service's account proof. If this value is empty, then `rootHash` will
/// be used as the signal root, otherwise, `rootHash` will be used as the state root.
bytes[] accountProof;
/// @notice The signal service's storage proof.
bytes[] storageProof;
}
/// @notice Emitted when a remote chain's state root or signal root is
/// synced locally as a signal.
/// @param chainId The remote chainId.
/// @param blockId The chain data's corresponding blockId.
/// @param kind A value to mark the data type.
/// @param data The remote data.
/// @param signal The signal for this chain data.
event ChainDataSynced(
uint64 indexed chainId,
uint64 indexed blockId,
bytes32 indexed kind,
bytes32 data,
bytes32 signal
);
/// @notice Emitted when signals are received directly by TaikoL2 in its Anchor transaction.
/// @param signalSlots The signal slots that were received.
event SignalsReceived(bytes32[] signalSlots);
/// @notice Emitted when a signal is sent.
/// @param app The address that initiated the signal.
/// @param signal The signal (message) that was sent.
/// @param slot The location in storage where this signal is stored.
/// @param value The value of the signal.
event SignalSent(address app, bytes32 signal, bytes32 slot, bytes32 value);
/// @notice Emitted when an address is authorized or deauthorized.
/// @param addr The address to be authorized or deauthorized.
/// @param authorized True if authorized, false otherwise.
event Authorized(address indexed addr, bool authorized);
/// @dev Allow TaikoL2 to receive signals directly in its Anchor transaction.
/// @param _signalSlots The signal slots to mark as received.
function receiveSignals(bytes32[] calldata _signalSlots) external;
/// @notice Send a signal (message) by setting the storage slot to the same value as the signal
/// itself.
/// @param _signal The signal (message) to send.
/// @return slot_ The location in storage where this signal is stored.
function sendSignal(bytes32 _signal) external returns (bytes32 slot_);
/// @notice Sync a data from a remote chain locally as a signal. The signal is calculated
/// uniquely from chainId, kind, and data.
/// @param _chainId The remote chainId.
/// @param _kind A value to mark the data type.
/// @param _blockId The chain data's corresponding blockId
/// @param _chainData The remote data.
/// @return signal_ The signal for this chain data.
function syncChainData(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId,
bytes32 _chainData
)
external
returns (bytes32 signal_);
/// @notice Verifies if a signal has been received on the target chain.
/// @param _chainId The identifier for the source chain from which the
/// signal originated.
/// @param _app The address that initiated the signal.
/// @param _signal The signal (message) to send.
/// @param _proof Merkle proof that the signal was persisted on the
/// source chain. If this proof is empty, then we check if this signal has been marked as
/// received by TaikoL2.
/// @return numCacheOps_ The number of newly cached items.
function proveSignalReceived(
uint64 _chainId,
address _app,
bytes32 _signal,
bytes calldata _proof
)
external
returns (uint256 numCacheOps_);
/// @notice Verifies if a signal has been received on the target chain.
/// This is the "readonly" version of proveSignalReceived.
/// @param _chainId The identifier for the source chain from which the
/// signal originated.
/// @param _app The address that initiated the signal.
/// @param _signal The signal (message) to send.
/// @param _proof Merkle proof that the signal was persisted on the
/// source chain. If this proof is empty, then we check if this signal has been marked as
/// received by TaikoL2.
function verifySignalReceived(
uint64 _chainId,
address _app,
bytes32 _signal,
bytes calldata _proof
)
external
view;
/// @notice Verifies if a particular signal has already been sent.
/// @param _app The address that initiated the signal.
/// @param _signal The signal (message) that was sent.
/// @return true if the signal has been sent, otherwise false.
function isSignalSent(address _app, bytes32 _signal) external view returns (bool);
/// @notice Verifies if a particular signal has already been sent.
/// @param _signalSlot The location in storage where this signal is stored.
function isSignalSent(bytes32 _signalSlot) external view returns (bool);
/// @notice Checks if a chain data has been synced.
/// @param _chainId The remote chainId.
/// @param _kind A value to mark the data type.
/// @param _blockId The chain data's corresponding blockId
/// @param _chainData The remote data.
/// @return true if the data has been synced, otherwise false.
function isChainDataSynced(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId,
bytes32 _chainData
)
external
view
returns (bool);
/// @notice Returns the given block's chain data.
/// @param _chainId Identifier of the chainId.
/// @param _kind A value to mark the data type.
/// @param _blockId The chain data's corresponding block id. If this value is 0, use the top
/// block id.
/// @return blockId_ The actual block id.
/// @return chainData_ The synced chain data.
function getSyncedChainData(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId
)
external
view
returns (uint64 blockId_, bytes32 chainData_);
/// @notice Returns the data to be used for caching slot generation.
/// @param _chainId Identifier of the chainId.
/// @param _kind A value to mark the data type.
/// @param _blockId The chain data's corresponding block id. If this value is 0, use the top
/// block id.
/// @return signal_ The signal used for caching slot creation.
function signalForChainData(
uint64 _chainId,
bytes32 _kind,
uint64 _blockId
)
external
pure
returns (bytes32 signal_);
}
node_modules/@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)
pragma solidity ^0.8.0;
import "./OwnableUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership} and {acceptOwnership}.
*
* This module is used through inheritance. It will make available all functions
* from parent (Ownable).
*/
abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
address private _pendingOwner;
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function __Ownable2Step_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable2Step_init_unchained() internal onlyInitializing {
}
/**
* @dev Returns the address of the pending owner.
*/
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
/**
* @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
* Can only be called by the current owner.
*/
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;
}
node_modules/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @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;
}
node_modules/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* 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;
}
}
node_modules/@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// 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);
}
}
}
node_modules/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)
pragma solidity ^0.8.0;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
node_modules/@openzeppelin/contracts/interfaces/IERC1967.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
*
* _Available since v4.8.3._
*/
interface IERC1967 {
/**
* @dev Emitted when the implementation is upgraded.
*/
event Upgraded(address indexed implementation);
/**
* @dev Emitted when the admin account has changed.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Emitted when the beacon is changed.
*/
event BeaconUpgraded(address indexed beacon);
}
node_modules/@openzeppelin/contracts/interfaces/draft-IERC1822.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
* proxy whose upgrades are fully controlled by the current implementation.
*/
interface IERC1822Proxiable {
/**
* @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
* address.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy.
*/
function proxiableUUID() external view returns (bytes32);
}
node_modules/@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)
pragma solidity ^0.8.2;
import "../beacon/IBeacon.sol";
import "../../interfaces/IERC1967.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";
/**
* @dev This abstract contract provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
*
* _Available since v4.1._
*/
abstract contract ERC1967Upgrade is IERC1967 {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 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);
}
}
}
node_modules/@openzeppelin/contracts/proxy/beacon/IBeacon.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
pragma solidity ^0.8.0;
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeacon {
/**
* @dev Must return an address that can be used as a delegate call target.
*
* {BeaconProxy} will check that this address is a contract.
*/
function implementation() external view returns (address);
}
node_modules/@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)
pragma solidity ^0.8.0;
import "../../interfaces/draft-IERC1822.sol";
import "../ERC1967/ERC1967Upgrade.sol";
/**
* @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
* {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
*
* A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
* reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
* `UUPSUpgradeable` with a custom implementation of upgrades.
*
* The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
*
* _Available since v4.1._
*/
abstract contract UUPSUpgradeable is IERC1822Proxiable, ERC1967Upgrade {
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-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;
}
node_modules/@openzeppelin/contracts/utils/Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// 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);
}
}
}
node_modules/@openzeppelin/contracts/utils/StorageSlot.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
pragma solidity ^0.8.0;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```solidity
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
* _Available since v4.9 for `string`, `bytes`._
*/
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
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
}
}
}
node_modules/optimism/packages/contracts-bedrock/src/libraries/Bytes.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Bytes
/// @notice Bytes is a library for manipulating byte arrays.
library Bytes {
/// @custom:attribution https://github.com/GNSPS/solidity-bytes-utils
/// @notice Slices a byte array with a given starting index and length. Returns a new byte array
/// as opposed to a pointer to the original array. Will throw if trying to slice more
/// bytes than exist in the array.
/// @param _bytes Byte array to slice.
/// @param _start Starting index of the slice.
/// @param _length Length of the slice.
/// @return Slice of the input byte array.
function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {
unchecked {
require(_length + 31 >= _length, "slice_overflow");
require(_start + _length >= _start, "slice_overflow");
require(_bytes.length >= _start + _length, "slice_outOfBounds");
}
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
let lengthmod := and(_length, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, _length)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} { mstore(mc, mload(cc)) }
mstore(tempBytes, _length)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
//zero out the 32 bytes slice we are about to return
//we need to do it because Solidity does not garbage collect
mstore(tempBytes, 0)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
/// @notice Slices a byte array with a given starting index up to the end of the original byte
/// array. Returns a new array rathern than a pointer to the original.
/// @param _bytes Byte array to slice.
/// @param _start Starting index of the slice.
/// @return Slice of the input byte array.
function slice(bytes memory _bytes, uint256 _start) internal pure returns (bytes memory) {
if (_start >= _bytes.length) {
return bytes("");
}
return slice(_bytes, _start, _bytes.length - _start);
}
/// @notice Converts a byte array into a nibble array by splitting each byte into two nibbles.
/// Resulting nibble array will be exactly twice as long as the input byte array.
/// @param _bytes Input byte array to convert.
/// @return Resulting nibble array.
function toNibbles(bytes memory _bytes) internal pure returns (bytes memory) {
bytes memory _nibbles;
assembly {
// Grab a free memory offset for the new array
_nibbles := mload(0x40)
// Load the length of the passed bytes array from memory
let bytesLength := mload(_bytes)
// Calculate the length of the new nibble array
// This is the length of the input array times 2
let nibblesLength := shl(0x01, bytesLength)
// Update the free memory pointer to allocate memory for the new array.
// To do this, we add the length of the new array + 32 bytes for the array length
// rounded up to the nearest 32 byte boundary to the current free memory pointer.
mstore(0x40, add(_nibbles, and(not(0x1F), add(nibblesLength, 0x3F))))
// Store the length of the new array in memory
mstore(_nibbles, nibblesLength)
// Store the memory offset of the _bytes array's contents on the stack
let bytesStart := add(_bytes, 0x20)
// Store the memory offset of the nibbles array's contents on the stack
let nibblesStart := add(_nibbles, 0x20)
// Loop through each byte in the input array
for { let i := 0x00 } lt(i, bytesLength) { i := add(i, 0x01) } {
// Get the starting offset of the next 2 bytes in the nibbles array
let offset := add(nibblesStart, shl(0x01, i))
// Load the byte at the current index within the `_bytes` array
let b := byte(0x00, mload(add(bytesStart, i)))
// Pull out the first nibble and store it in the new array
mstore8(offset, shr(0x04, b))
// Pull out the second nibble and store it in the new array
mstore8(add(offset, 0x01), and(b, 0x0F))
}
}
return _nibbles;
}
/// @notice Compares two byte arrays by comparing their keccak256 hashes.
/// @param _bytes First byte array to compare.
/// @param _other Second byte array to compare.
/// @return True if the two byte arrays are equal, false otherwise.
function equal(bytes memory _bytes, bytes memory _other) internal pure returns (bool) {
return keccak256(_bytes) == keccak256(_other);
}
}
node_modules/optimism/packages/contracts-bedrock/src/libraries/rlp/RLPErrors.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @notice The length of an RLP item must be greater than zero to be decodable
error EmptyItem();
/// @notice The decoded item type for list is not a list item
error UnexpectedString();
/// @notice The RLP item has an invalid data remainder
error InvalidDataRemainder();
/// @notice Decoded item type for bytes is not a string item
error UnexpectedList();
/// @notice The length of the content must be greater than the RLP item length
error ContentLengthMismatch();
/// @notice Invalid RLP header for RLP item
error InvalidHeader();
node_modules/optimism/packages/contracts-bedrock/src/libraries/rlp/RLPReader.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
import "./RLPErrors.sol";
/// @custom:attribution https://github.com/hamdiallam/Solidity-RLP
/// @title RLPReader
/// @notice RLPReader is a library for parsing RLP-encoded byte arrays into Solidity types. Adapted
/// from Solidity-RLP (https://github.com/hamdiallam/Solidity-RLP) by Hamdi Allam with
/// various tweaks to improve readability.
library RLPReader {
/// @notice Custom pointer type to avoid confusion between pointers and uint256s.
type MemoryPointer is uint256;
/// @notice RLP item types.
/// @custom:value DATA_ITEM Represents an RLP data item (NOT a list).
/// @custom:value LIST_ITEM Represents an RLP list item.
enum RLPItemType {
DATA_ITEM,
LIST_ITEM
}
/// @notice Struct representing an RLP item.
/// @custom:field length Length of the RLP item.
/// @custom:field ptr Pointer to the RLP item in memory.
struct RLPItem {
uint256 length;
MemoryPointer ptr;
}
/// @notice Max list length that this library will accept.
uint256 internal constant MAX_LIST_LENGTH = 32;
/// @notice Converts bytes to a reference to memory position and length.
/// @param _in Input bytes to convert.
/// @return out_ Output memory reference.
function toRLPItem(bytes memory _in) internal pure returns (RLPItem memory out_) {
// Empty arrays are not RLP items.
if (_in.length == 0) revert EmptyItem();
MemoryPointer ptr;
assembly {
ptr := add(_in, 32)
}
out_ = RLPItem({ length: _in.length, ptr: ptr });
}
/// @notice Reads an RLP list value into a list of RLP items.
/// @param _in RLP list value.
/// @return out_ Decoded RLP list items.
function readList(RLPItem memory _in) internal pure returns (RLPItem[] memory out_) {
(uint256 listOffset, uint256 listLength, RLPItemType itemType) = _decodeLength(_in);
if (itemType != RLPItemType.LIST_ITEM) revert UnexpectedString();
if (listOffset + listLength != _in.length) revert InvalidDataRemainder();
// Solidity in-memory arrays can't be increased in size, but *can* be decreased in size by
// writing to the length. Since we can't know the number of RLP items without looping over
// the entire input, we'd have to loop twice to accurately size this array. It's easier to
// simply set a reasonable maximum list length and decrease the size before we finish.
out_ = new RLPItem[](MAX_LIST_LENGTH);
uint256 itemCount = 0;
uint256 offset = listOffset;
while (offset < _in.length) {
(uint256 itemOffset, uint256 itemLength,) = _decodeLength(
RLPItem({ length: _in.length - offset, ptr: MemoryPointer.wrap(MemoryPointer.unwrap(_in.ptr) + offset) })
);
// We don't need to check itemCount < out.length explicitly because Solidity already
// handles this check on our behalf, we'd just be wasting gas.
out_[itemCount] = RLPItem({
length: itemLength + itemOffset,
ptr: MemoryPointer.wrap(MemoryPointer.unwrap(_in.ptr) + offset)
});
itemCount += 1;
offset += itemOffset + itemLength;
}
// Decrease the array size to match the actual item count.
assembly {
mstore(out_, itemCount)
}
}
/// @notice Reads an RLP list value into a list of RLP items.
/// @param _in RLP list value.
/// @return out_ Decoded RLP list items.
function readList(bytes memory _in) internal pure returns (RLPItem[] memory out_) {
out_ = readList(toRLPItem(_in));
}
/// @notice Reads an RLP bytes value into bytes.
/// @param _in RLP bytes value.
/// @return out_ Decoded bytes.
function readBytes(RLPItem memory _in) internal pure returns (bytes memory out_) {
(uint256 itemOffset, uint256 itemLength, RLPItemType itemType) = _decodeLength(_in);
if (itemType != RLPItemType.DATA_ITEM) revert UnexpectedList();
if (_in.length != itemOffset + itemLength) revert InvalidDataRemainder();
out_ = _copy(_in.ptr, itemOffset, itemLength);
}
/// @notice Reads an RLP bytes value into bytes.
/// @param _in RLP bytes value.
/// @return out_ Decoded bytes.
function readBytes(bytes memory _in) internal pure returns (bytes memory out_) {
out_ = readBytes(toRLPItem(_in));
}
/// @notice Reads the raw bytes of an RLP item.
/// @param _in RLP item to read.
/// @return out_ Raw RLP bytes.
function readRawBytes(RLPItem memory _in) internal pure returns (bytes memory out_) {
out_ = _copy(_in.ptr, 0, _in.length);
}
/// @notice Decodes the length of an RLP item.
/// @param _in RLP item to decode.
/// @return offset_ Offset of the encoded data.
/// @return length_ Length of the encoded data.
/// @return type_ RLP item type (LIST_ITEM or DATA_ITEM).
function _decodeLength(RLPItem memory _in)
private
pure
returns (uint256 offset_, uint256 length_, RLPItemType type_)
{
// Short-circuit if there's nothing to decode, note that we perform this check when
// the user creates an RLP item via toRLPItem, but it's always possible for them to bypass
// that function and create an RLP item directly. So we need to check this anyway.
if (_in.length == 0) revert EmptyItem();
MemoryPointer ptr = _in.ptr;
uint256 prefix;
assembly {
prefix := byte(0, mload(ptr))
}
if (prefix <= 0x7f) {
// Single byte.
return (0, 1, RLPItemType.DATA_ITEM);
} else if (prefix <= 0xb7) {
// Short string.
// slither-disable-next-line variable-scope
uint256 strLen = prefix - 0x80;
if (_in.length <= strLen) revert ContentLengthMismatch();
bytes1 firstByteOfContent;
assembly {
firstByteOfContent := and(mload(add(ptr, 1)), shl(248, 0xff))
}
if (strLen == 1 && firstByteOfContent < 0x80) revert InvalidHeader();
return (1, strLen, RLPItemType.DATA_ITEM);
} else if (prefix <= 0xbf) {
// Long string.
uint256 lenOfStrLen = prefix - 0xb7;
if (_in.length <= lenOfStrLen) revert ContentLengthMismatch();
bytes1 firstByteOfContent;
assembly {
firstByteOfContent := and(mload(add(ptr, 1)), shl(248, 0xff))
}
if (firstByteOfContent == 0x00) revert InvalidHeader();
uint256 strLen;
assembly {
strLen := shr(sub(256, mul(8, lenOfStrLen)), mload(add(ptr, 1)))
}
if (strLen <= 55) revert InvalidHeader();
if (_in.length <= lenOfStrLen + strLen) revert ContentLengthMismatch();
return (1 + lenOfStrLen, strLen, RLPItemType.DATA_ITEM);
} else if (prefix <= 0xf7) {
// Short list.
// slither-disable-next-line variable-scope
uint256 listLen = prefix - 0xc0;
if (_in.length <= listLen) revert ContentLengthMismatch();
return (1, listLen, RLPItemType.LIST_ITEM);
} else {
// Long list.
uint256 lenOfListLen = prefix - 0xf7;
if (_in.length <= lenOfListLen) revert ContentLengthMismatch();
bytes1 firstByteOfContent;
assembly {
firstByteOfContent := and(mload(add(ptr, 1)), shl(248, 0xff))
}
if (firstByteOfContent == 0x00) revert InvalidHeader();
uint256 listLen;
assembly {
listLen := shr(sub(256, mul(8, lenOfListLen)), mload(add(ptr, 1)))
}
if (listLen <= 55) revert InvalidHeader();
if (_in.length <= lenOfListLen + listLen) revert ContentLengthMismatch();
return (1 + lenOfListLen, listLen, RLPItemType.LIST_ITEM);
}
}
/// @notice Copies the bytes from a memory location.
/// @param _src Pointer to the location to read from.
/// @param _offset Offset to start reading from.
/// @param _length Number of bytes to read.
/// @return out_ Copied bytes.
function _copy(MemoryPointer _src, uint256 _offset, uint256 _length) private pure returns (bytes memory out_) {
out_ = new bytes(_length);
if (_length == 0) {
return out_;
}
// Mostly based on Solidity's copy_memory_to_memory:
// https://github.com/ethereum/solidity/blob/34dd30d71b4da730488be72ff6af7083cf2a91f6/libsolidity/codegen/YulUtilFunctions.cpp#L102-L114
uint256 src = MemoryPointer.unwrap(_src) + _offset;
assembly {
let dest := add(out_, 32)
let i := 0
for { } lt(i, _length) { i := add(i, 32) } { mstore(add(dest, i), mload(add(src, i))) }
if gt(i, _length) { mstore(add(dest, _length), 0) }
}
}
}
node_modules/optimism/packages/contracts-bedrock/src/libraries/rlp/RLPWriter.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @custom:attribution https://github.com/bakaoh/solidity-rlp-encode
/// @title RLPWriter
/// @author RLPWriter is a library for encoding Solidity types to RLP bytes. Adapted from Bakaoh's
/// RLPEncode library (https://github.com/bakaoh/solidity-rlp-encode) with minor
/// modifications to improve legibility.
library RLPWriter {
/// @notice RLP encodes a byte string.
/// @param _in The byte string to encode.
/// @return out_ The RLP encoded string in bytes.
function writeBytes(bytes memory _in) internal pure returns (bytes memory out_) {
if (_in.length == 1 && uint8(_in[0]) < 128) {
out_ = _in;
} else {
out_ = abi.encodePacked(_writeLength(_in.length, 128), _in);
}
}
/// @notice RLP encodes a list of RLP encoded byte byte strings.
/// @param _in The list of RLP encoded byte strings.
/// @return list_ The RLP encoded list of items in bytes.
function writeList(bytes[] memory _in) internal pure returns (bytes memory list_) {
list_ = _flatten(_in);
list_ = abi.encodePacked(_writeLength(list_.length, 192), list_);
}
/// @notice RLP encodes a string.
/// @param _in The string to encode.
/// @return out_ The RLP encoded string in bytes.
function writeString(string memory _in) internal pure returns (bytes memory out_) {
out_ = writeBytes(bytes(_in));
}
/// @notice RLP encodes an address.
/// @param _in The address to encode.
/// @return out_ The RLP encoded address in bytes.
function writeAddress(address _in) internal pure returns (bytes memory out_) {
out_ = writeBytes(abi.encodePacked(_in));
}
/// @notice RLP encodes a uint.
/// @param _in The uint256 to encode.
/// @return out_ The RLP encoded uint256 in bytes.
function writeUint(uint256 _in) internal pure returns (bytes memory out_) {
out_ = writeBytes(_toBinary(_in));
}
/// @notice RLP encodes a bool.
/// @param _in The bool to encode.
/// @return out_ The RLP encoded bool in bytes.
function writeBool(bool _in) internal pure returns (bytes memory out_) {
out_ = new bytes(1);
out_[0] = (_in ? bytes1(0x01) : bytes1(0x80));
}
/// @notice Encode the first byte and then the `len` in binary form if `length` is more than 55.
/// @param _len The length of the string or the payload.
/// @param _offset 128 if item is string, 192 if item is list.
/// @return out_ RLP encoded bytes.
function _writeLength(uint256 _len, uint256 _offset) private pure returns (bytes memory out_) {
if (_len < 56) {
out_ = new bytes(1);
out_[0] = bytes1(uint8(_len) + uint8(_offset));
} else {
uint256 lenLen;
uint256 i = 1;
while (_len / i != 0) {
lenLen++;
i *= 256;
}
out_ = new bytes(lenLen + 1);
out_[0] = bytes1(uint8(lenLen) + uint8(_offset) + 55);
for (i = 1; i <= lenLen; i++) {
out_[i] = bytes1(uint8((_len / (256 ** (lenLen - i))) % 256));
}
}
}
/// @notice Encode integer in big endian binary form with no leading zeroes.
/// @param _x The integer to encode.
/// @return out_ RLP encoded bytes.
function _toBinary(uint256 _x) private pure returns (bytes memory out_) {
bytes memory b = abi.encodePacked(_x);
uint256 i = 0;
for (; i < 32; i++) {
if (b[i] != 0) {
break;
}
}
out_ = new bytes(32 - i);
for (uint256 j = 0; j < out_.length; j++) {
out_[j] = b[i++];
}
}
/// @custom:attribution https://github.com/Arachnid/solidity-stringutils
/// @notice Copies a piece of memory to another location.
/// @param _dest Destination location.
/// @param _src Source location.
/// @param _len Length of memory to copy.
function _memcpy(uint256 _dest, uint256 _src, uint256 _len) private pure {
uint256 dest = _dest;
uint256 src = _src;
uint256 len = _len;
for (; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint256 mask;
unchecked {
mask = 256 ** (32 - len) - 1;
}
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
/// @custom:attribution https://github.com/sammayo/solidity-rlp-encoder
/// @notice Flattens a list of byte strings into one byte string.
/// @param _list List of byte strings to flatten.
/// @return out_ The flattened byte string.
function _flatten(bytes[] memory _list) private pure returns (bytes memory out_) {
if (_list.length == 0) {
return new bytes(0);
}
uint256 len;
uint256 i = 0;
for (; i < _list.length; i++) {
len += _list[i].length;
}
out_ = new bytes(len);
uint256 flattenedPtr;
assembly {
flattenedPtr := add(out_, 0x20)
}
for (i = 0; i < _list.length; i++) {
bytes memory item = _list[i];
uint256 listPtr;
assembly {
listPtr := add(item, 0x20)
}
_memcpy(flattenedPtr, listPtr, item.length);
flattenedPtr += _list[i].length;
}
}
}
node_modules/optimism/packages/contracts-bedrock/src/libraries/trie/MerkleTrie.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { Bytes } from "../Bytes.sol";
import { RLPReader } from "../rlp/RLPReader.sol";
/// @title MerkleTrie
/// @notice MerkleTrie is a small library for verifying standard Ethereum Merkle-Patricia trie
/// inclusion proofs. By default, this library assumes a hexary trie. One can change the
/// trie radix constant to support other trie radixes.
library MerkleTrie {
/// @notice Struct representing a node in the trie.
/// @custom:field encoded The RLP-encoded node.
/// @custom:field decoded The RLP-decoded node.
struct TrieNode {
bytes encoded;
RLPReader.RLPItem[] decoded;
}
/// @notice Determines the number of elements per branch node.
uint256 internal constant TREE_RADIX = 16;
/// @notice Branch nodes have TREE_RADIX elements and one value element.
uint256 internal constant BRANCH_NODE_LENGTH = TREE_RADIX + 1;
/// @notice Leaf nodes and extension nodes have two elements, a `path` and a `value`.
uint256 internal constant LEAF_OR_EXTENSION_NODE_LENGTH = 2;
/// @notice Prefix for even-nibbled extension node paths.
uint8 internal constant PREFIX_EXTENSION_EVEN = 0;
/// @notice Prefix for odd-nibbled extension node paths.
uint8 internal constant PREFIX_EXTENSION_ODD = 1;
/// @notice Prefix for even-nibbled leaf node paths.
uint8 internal constant PREFIX_LEAF_EVEN = 2;
/// @notice Prefix for odd-nibbled leaf node paths.
uint8 internal constant PREFIX_LEAF_ODD = 3;
/// @notice Verifies a proof that a given key/value pair is present in the trie.
/// @param _key Key of the node to search for, as a hex string.
/// @param _value Value of the node to search for, as a hex string.
/// @param _proof Merkle trie inclusion proof for the desired node. Unlike traditional Merkle
/// trees, this proof is executed top-down and consists of a list of RLP-encoded
/// nodes that make a path down to the target node.
/// @param _root Known root of the Merkle trie. Used to verify that the included proof is
/// correctly constructed.
/// @return valid_ Whether or not the proof is valid.
function verifyInclusionProof(
bytes memory _key,
bytes memory _value,
bytes[] memory _proof,
bytes32 _root
)
internal
pure
returns (bool valid_)
{
valid_ = Bytes.equal(_value, get(_key, _proof, _root));
}
/// @notice Retrieves the value associated with a given key.
/// @param _key Key to search for, as hex bytes.
/// @param _proof Merkle trie inclusion proof for the key.
/// @param _root Known root of the Merkle trie.
/// @return value_ Value of the key if it exists.
function get(bytes memory _key, bytes[] memory _proof, bytes32 _root) internal pure returns (bytes memory value_) {
require(_key.length > 0, "MerkleTrie: empty key");
TrieNode[] memory proof = _parseProof(_proof);
bytes memory key = Bytes.toNibbles(_key);
bytes memory currentNodeID = abi.encodePacked(_root);
uint256 currentKeyIndex = 0;
// Proof is top-down, so we start at the first element (root).
for (uint256 i = 0; i < proof.length; i++) {
TrieNode memory currentNode = proof[i];
// Key index should never exceed total key length or we'll be out of bounds.
require(currentKeyIndex <= key.length, "MerkleTrie: key index exceeds total key length");
if (currentKeyIndex == 0) {
// First proof element is always the root node.
require(
Bytes.equal(abi.encodePacked(keccak256(currentNode.encoded)), currentNodeID),
"MerkleTrie: invalid root hash"
);
} else if (currentNode.encoded.length >= 32) {
// Nodes 32 bytes or larger are hashed inside branch nodes.
require(
Bytes.equal(abi.encodePacked(keccak256(currentNode.encoded)), currentNodeID),
"MerkleTrie: invalid large internal hash"
);
} else {
// Nodes smaller than 32 bytes aren't hashed.
require(Bytes.equal(currentNode.encoded, currentNodeID), "MerkleTrie: invalid internal node hash");
}
if (currentNode.decoded.length == BRANCH_NODE_LENGTH) {
if (currentKeyIndex == key.length) {
// Value is the last element of the decoded list (for branch nodes). There's
// some ambiguity in the Merkle trie specification because bytes(0) is a
// valid value to place into the trie, but for branch nodes bytes(0) can exist
// even when the value wasn't explicitly placed there. Geth treats a value of
// bytes(0) as "key does not exist" and so we do the same.
value_ = RLPReader.readBytes(currentNode.decoded[TREE_RADIX]);
require(value_.length > 0, "MerkleTrie: value length must be greater than zero (branch)");
// Extra proof elements are not allowed.
require(i == proof.length - 1, "MerkleTrie: value node must be last node in proof (branch)");
return value_;
} else {
// We're not at the end of the key yet.
// Figure out what the next node ID should be and continue.
uint8 branchKey = uint8(key[currentKeyIndex]);
RLPReader.RLPItem memory nextNode = currentNode.decoded[branchKey];
currentNodeID = _getNodeID(nextNode);
currentKeyIndex += 1;
}
} else if (currentNode.decoded.length == LEAF_OR_EXTENSION_NODE_LENGTH) {
bytes memory path = _getNodePath(currentNode);
uint8 prefix = uint8(path[0]);
uint8 offset = 2 - (prefix % 2);
bytes memory pathRemainder = Bytes.slice(path, offset);
bytes memory keyRemainder = Bytes.slice(key, currentKeyIndex);
uint256 sharedNibbleLength = _getSharedNibbleLength(pathRemainder, keyRemainder);
// Whether this is a leaf node or an extension node, the path remainder MUST be a
// prefix of the key remainder (or be equal to the key remainder) or the proof is
// considered invalid.
require(
pathRemainder.length == sharedNibbleLength,
"MerkleTrie: path remainder must share all nibbles with key"
);
if (prefix == PREFIX_LEAF_EVEN || prefix == PREFIX_LEAF_ODD) {
// Prefix of 2 or 3 means this is a leaf node. For the leaf node to be valid,
// the key remainder must be exactly equal to the path remainder. We already
// did the necessary byte comparison, so it's more efficient here to check that
// the key remainder length equals the shared nibble length, which implies
// equality with the path remainder (since we already did the same check with
// the path remainder and the shared nibble length).
require(
keyRemainder.length == sharedNibbleLength,
"MerkleTrie: key remainder must be identical to path remainder"
);
// Our Merkle Trie is designed specifically for the purposes of the Ethereum
// state trie. Empty values are not allowed in the state trie, so we can safely
// say that if the value is empty, the key should not exist and the proof is
// invalid.
value_ = RLPReader.readBytes(currentNode.decoded[1]);
require(value_.length > 0, "MerkleTrie: value length must be greater than zero (leaf)");
// Extra proof elements are not allowed.
require(i == proof.length - 1, "MerkleTrie: value node must be last node in proof (leaf)");
return value_;
} else if (prefix == PREFIX_EXTENSION_EVEN || prefix == PREFIX_EXTENSION_ODD) {
// Prefix of 0 or 1 means this is an extension node. We move onto the next node
// in the proof and increment the key index by the length of the path remainder
// which is equal to the shared nibble length.
currentNodeID = _getNodeID(currentNode.decoded[1]);
currentKeyIndex += sharedNibbleLength;
} else {
revert("MerkleTrie: received a node with an unknown prefix");
}
} else {
revert("MerkleTrie: received an unparseable node");
}
}
revert("MerkleTrie: ran out of proof elements");
}
/// @notice Parses an array of proof elements into a new array that contains both the original
/// encoded element and the RLP-decoded element.
/// @param _proof Array of proof elements to parse.
/// @return proof_ Proof parsed into easily accessible structs.
function _parseProof(bytes[] memory _proof) private pure returns (TrieNode[] memory proof_) {
uint256 length = _proof.length;
proof_ = new TrieNode[](length);
for (uint256 i = 0; i < length;) {
proof_[i] = TrieNode({ encoded: _proof[i], decoded: RLPReader.readList(_proof[i]) });
unchecked {
++i;
}
}
}
/// @notice Picks out the ID for a node. Node ID is referred to as the "hash" within the
/// specification, but nodes < 32 bytes are not actually hashed.
/// @param _node Node to pull an ID for.
/// @return id_ ID for the node, depending on the size of its contents.
function _getNodeID(RLPReader.RLPItem memory _node) private pure returns (bytes memory id_) {
id_ = _node.length < 32 ? RLPReader.readRawBytes(_node) : RLPReader.readBytes(_node);
}
/// @notice Gets the path for a leaf or extension node.
/// @param _node Node to get a path for.
/// @return nibbles_ Node path, converted to an array of nibbles.
function _getNodePath(TrieNode memory _node) private pure returns (bytes memory nibbles_) {
nibbles_ = Bytes.toNibbles(RLPReader.readBytes(_node.decoded[0]));
}
/// @notice Utility; determines the number of nibbles shared between two nibble arrays.
/// @param _a First nibble array.
/// @param _b Second nibble array.
/// @return shared_ Number of shared nibbles.
function _getSharedNibbleLength(bytes memory _a, bytes memory _b) private pure returns (uint256 shared_) {
uint256 max = (_a.length < _b.length) ? _a.length : _b.length;
for (; shared_ < max && _a[shared_] == _b[shared_];) {
unchecked {
++shared_;
}
}
}
}
node_modules/optimism/packages/contracts-bedrock/src/libraries/trie/SecureMerkleTrie.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { MerkleTrie } from "./MerkleTrie.sol";
/// @title SecureMerkleTrie
/// @notice SecureMerkleTrie is a thin wrapper around the MerkleTrie library that hashes the input
/// keys. Ethereum's state trie hashes input keys before storing them.
library SecureMerkleTrie {
/// @notice Verifies a proof that a given key/value pair is present in the Merkle trie.
/// @param _key Key of the node to search for, as a hex string.
/// @param _value Value of the node to search for, as a hex string.
/// @param _proof Merkle trie inclusion proof for the desired node. Unlike traditional Merkle
/// trees, this proof is executed top-down and consists of a list of RLP-encoded
/// nodes that make a path down to the target node.
/// @param _root Known root of the Merkle trie. Used to verify that the included proof is
/// correctly constructed.
/// @return valid_ Whether or not the proof is valid.
function verifyInclusionProof(
bytes memory _key,
bytes memory _value,
bytes[] memory _proof,
bytes32 _root
)
internal
pure
returns (bool valid_)
{
bytes memory key = _getSecureKey(_key);
valid_ = MerkleTrie.verifyInclusionProof(key, _value, _proof, _root);
}
/// @notice Retrieves the value associated with a given key.
/// @param _key Key to search for, as hex bytes.
/// @param _proof Merkle trie inclusion proof for the key.
/// @param _root Known root of the Merkle trie.
/// @return value_ Value of the key if it exists.
function get(bytes memory _key, bytes[] memory _proof, bytes32 _root) internal pure returns (bytes memory value_) {
bytes memory key = _getSecureKey(_key);
value_ = MerkleTrie.get(key, _proof, _root);
}
/// @notice Computes the hashed version of the input key.
/// @param _key Key to hash.
/// @return hash_ Hashed version of the key.
function _getSecureKey(bytes memory _key) private pure returns (bytes memory hash_) {
hash_ = abi.encodePacked(keccak256(_key));
}
}
Compiler Settings
{"viaIR":false,"remappings":["openzeppelin/=node_modules/@openzeppelin/","@openzeppelin/=node_modules/@openzeppelin/","@openzeppelin-upgrades/contracts/=node_modules/@openzeppelin/contracts-upgradeable/","@risc0/contracts/=node_modules/risc0-ethereum/contracts/src/","@solady/=node_modules/solady/","@optimism/=node_modules/optimism/","@sp1-contracts/=node_modules/sp1-contracts/contracts/","forge-std/=node_modules/forge-std/","ds-test/=node_modules/ds-test/src/","@p256-verifier/contracts/=node_modules/p256-verifier/src/","eigenlayer-middleware/=node_modules/eigenlayer-middleware/","eigenlayer-contracts/=node_modules/eigenlayer-contracts/","src/=contracts/","test/=test/","script/=script/","optimism/=node_modules/optimism/","p256-verifier/=node_modules/p256-verifier/","risc0-ethereum/=node_modules/risc0-ethereum/","solady/=node_modules/solady/","sp1-contracts/=node_modules/sp1-contracts/"],"outputSelection":{"*":{"*":["abi","evm.bytecode.object","evm.bytecode.sourceMap","evm.bytecode.linkReferences","evm.deployedBytecode.object","evm.deployedBytecode.sourceMap","evm.deployedBytecode.linkReferences","evm.deployedBytecode.immutableReferences","evm.methodIdentifiers","metadata"]}},"optimizer":{"runs":200,"enabled":true},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"libraries":{},"evmVersion":"shanghai"}
Contract ABI
[{"type":"constructor","stateMutability":"nonpayable","inputs":[{"type":"address","name":"_resolver","internalType":"address"}]},{"type":"error","name":"ACCESS_DENIED","inputs":[]},{"type":"error","name":"ContentLengthMismatch","inputs":[]},{"type":"error","name":"EmptyItem","inputs":[]},{"type":"error","name":"FUNC_NOT_IMPLEMENTED","inputs":[]},{"type":"error","name":"INVALID_PAUSE_STATUS","inputs":[]},{"type":"error","name":"InvalidDataRemainder","inputs":[]},{"type":"error","name":"InvalidHeader","inputs":[]},{"type":"error","name":"LTP_INVALID_ACCOUNT_PROOF","inputs":[]},{"type":"error","name":"LTP_INVALID_INCLUSION_PROOF","inputs":[]},{"type":"error","name":"REENTRANT_CALL","inputs":[]},{"type":"error","name":"RESOLVER_NOT_FOUND","inputs":[]},{"type":"error","name":"SS_EMPTY_PROOF","inputs":[]},{"type":"error","name":"SS_INVALID_HOPS_WITH_LOOP","inputs":[]},{"type":"error","name":"SS_INVALID_LAST_HOP_CHAINID","inputs":[]},{"type":"error","name":"SS_INVALID_MID_HOP_CHAINID","inputs":[]},{"type":"error","name":"SS_INVALID_STATE","inputs":[]},{"type":"error","name":"SS_SIGNAL_NOT_FOUND","inputs":[]},{"type":"error","name":"SS_SIGNAL_NOT_RECEIVED","inputs":[]},{"type":"error","name":"SS_UNAUTHORIZED","inputs":[]},{"type":"error","name":"UnexpectedList","inputs":[]},{"type":"error","name":"UnexpectedString","inputs":[]},{"type":"error","name":"ZERO_ADDRESS","inputs":[]},{"type":"error","name":"ZERO_VALUE","inputs":[]},{"type":"event","name":"AdminChanged","inputs":[{"type":"address","name":"previousAdmin","internalType":"address","indexed":false},{"type":"address","name":"newAdmin","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"Authorized","inputs":[{"type":"address","name":"addr","internalType":"address","indexed":true},{"type":"bool","name":"authorized","internalType":"bool","indexed":false}],"anonymous":false},{"type":"event","name":"BeaconUpgraded","inputs":[{"type":"address","name":"beacon","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"ChainDataSynced","inputs":[{"type":"uint64","name":"chainId","internalType":"uint64","indexed":true},{"type":"uint64","name":"blockId","internalType":"uint64","indexed":true},{"type":"bytes32","name":"kind","internalType":"bytes32","indexed":true},{"type":"bytes32","name":"data","internalType":"bytes32","indexed":false},{"type":"bytes32","name":"signal","internalType":"bytes32","indexed":false}],"anonymous":false},{"type":"event","name":"Initialized","inputs":[{"type":"uint8","name":"version","internalType":"uint8","indexed":false}],"anonymous":false},{"type":"event","name":"OwnershipTransferStarted","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"Paused","inputs":[{"type":"address","name":"account","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"SignalSent","inputs":[{"type":"address","name":"app","internalType":"address","indexed":false},{"type":"bytes32","name":"signal","internalType":"bytes32","indexed":false},{"type":"bytes32","name":"slot","internalType":"bytes32","indexed":false},{"type":"bytes32","name":"value","internalType":"bytes32","indexed":false}],"anonymous":false},{"type":"event","name":"SignalsReceived","inputs":[{"type":"bytes32[]","name":"signalSlots","internalType":"bytes32[]","indexed":false}],"anonymous":false},{"type":"event","name":"Unpaused","inputs":[{"type":"address","name":"account","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"Upgraded","inputs":[{"type":"address","name":"implementation","internalType":"address","indexed":true}],"anonymous":false},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"acceptOwnership","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"authorize","inputs":[{"type":"address","name":"_addr","internalType":"address"},{"type":"bool","name":"_authorize","internalType":"bool"}]},{"type":"function","stateMutability":"pure","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"getSignalSlot","inputs":[{"type":"uint64","name":"_chainId","internalType":"uint64"},{"type":"address","name":"_app","internalType":"address"},{"type":"bytes32","name":"_signal","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint64","name":"blockId_","internalType":"uint64"},{"type":"bytes32","name":"chainData_","internalType":"bytes32"}],"name":"getSyncedChainData","inputs":[{"type":"uint64","name":"_chainId","internalType":"uint64"},{"type":"bytes32","name":"_kind","internalType":"bytes32"},{"type":"uint64","name":"_blockId","internalType":"uint64"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"impl","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"inNonReentrant","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"init","inputs":[{"type":"address","name":"_owner","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"authorized","internalType":"bool"}],"name":"isAuthorized","inputs":[{"type":"address","name":"addr","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isChainDataSynced","inputs":[{"type":"uint64","name":"_chainId","internalType":"uint64"},{"type":"bytes32","name":"_kind","internalType":"bytes32"},{"type":"uint64","name":"_blockId","internalType":"uint64"},{"type":"bytes32","name":"_chainData","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isSignalSent","inputs":[{"type":"address","name":"_app","internalType":"address"},{"type":"bytes32","name":"_signal","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isSignalSent","inputs":[{"type":"bytes32","name":"_signalSlot","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"pause","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"paused","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"pendingOwner","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"uint256","name":"numCacheOps_","internalType":"uint256"}],"name":"proveSignalReceived","inputs":[{"type":"uint64","name":"_chainId","internalType":"uint64"},{"type":"address","name":"_app","internalType":"address"},{"type":"bytes32","name":"_signal","internalType":"bytes32"},{"type":"bytes","name":"_proof","internalType":"bytes"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"proxiableUUID","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"receiveSignals","inputs":[{"type":"bytes32[]","name":"_signalSlots","internalType":"bytes32[]"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"resolver","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"sendSignal","inputs":[{"type":"bytes32","name":"_signal","internalType":"bytes32"}]},{"type":"function","stateMutability":"pure","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"signalForChainData","inputs":[{"type":"uint64","name":"_chainId","internalType":"uint64"},{"type":"bytes32","name":"_kind","internalType":"bytes32"},{"type":"uint64","name":"_blockId","internalType":"uint64"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"syncChainData","inputs":[{"type":"uint64","name":"_chainId","internalType":"uint64"},{"type":"bytes32","name":"_kind","internalType":"bytes32"},{"type":"uint64","name":"_blockId","internalType":"uint64"},{"type":"bytes32","name":"_chainData","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint64","name":"blockId","internalType":"uint64"}],"name":"topBlockId","inputs":[{"type":"uint64","name":"chainId","internalType":"uint64"},{"type":"bytes32","name":"kind","internalType":"bytes32"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"unpause","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"upgradeTo","inputs":[{"type":"address","name":"newImplementation","internalType":"address"}]},{"type":"function","stateMutability":"payable","outputs":[],"name":"upgradeToAndCall","inputs":[{"type":"address","name":"newImplementation","internalType":"address"},{"type":"bytes","name":"data","internalType":"bytes"}]},{"type":"function","stateMutability":"view","outputs":[],"name":"verifySignalReceived","inputs":[{"type":"uint64","name":"_chainId","internalType":"uint64"},{"type":"address","name":"_app","internalType":"address"},{"type":"bytes32","name":"_signal","internalType":"bytes32"},{"type":"bytes","name":"_proof","internalType":"bytes"}]}]
Contract Creation Code
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 ByteCode
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