Skip to content

N
nebula
Commit c7b37b40 authored by Kelvin Fichter's avatar Kelvin Fichter
Browse files
Options

Started porting tests from contracts-v1

parent 6e1dbfe0
Show whitespace changes
Inline Side-by-side
Showing with 2897 additions and 12269 deletions
packages/contracts/.gitignore
View file @ c7b37b40
...@@ -2,3 +2,4 @@ node_modules/ ...@@ -2,3 +2,4 @@ node_modules/
artifacts/ artifacts/
cache/ cache/
yarn-error.log yarn-error.log
build/
packages/contracts/buidler.config.ts
View file @ c7b37b40
...@@ -8,7 +8,7 @@ import { ...@@ -8,7 +8,7 @@ import {
usePlugin('@nomiclabs/buidler-ethers') usePlugin('@nomiclabs/buidler-ethers')
usePlugin('@nomiclabs/buidler-waffle') usePlugin('@nomiclabs/buidler-waffle')
import './test/helpers/buidler/modify-compiler' import '@eth-optimism/smock/src/buidler-plugins/compiler-storage-layout'
const config: BuidlerConfig = { const config: BuidlerConfig = {
networks: { networks: {
......
packages/contracts/build/buidler.config.d.ts deleted 100644 → 0
View file @ 6e1dbfe0
import { BuidlerConfig } from '@nomiclabs/buidler/config';
import './test/helpers/buidler/modify-compiler';
declare const config: BuidlerConfig;
export default config;
packages/contracts/build/buidler.config.js deleted 100644 → 0
View file @ 6e1dbfe0
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const config_1 = require("@nomiclabs/buidler/config");
const constants_1 = require("./test/helpers/constants");
config_1.usePlugin('@nomiclabs/buidler-ethers');
config_1.usePlugin('@nomiclabs/buidler-waffle');
require("./test/helpers/buidler/modify-compiler");
const config = {
networks: {
buidlerevm: {
accounts: constants_1.DEFAULT_ACCOUNTS_BUIDLER,
blockGasLimit: constants_1.RUN_OVM_TEST_GAS * 2,
},
},
mocha: {
timeout: 50000,
},
solc: {
version: '0.7.0',
optimizer: { enabled: true, runs: 200 },
},
};
exports.default = config;
//# sourceMappingURL=buidler.config.js.map
\ No newline at end of file
packages/contracts/build/buidler.config.js.map deleted 100644 → 0
View file @ 6e1dbfe0
{"version":3,"file":"buidler.config.js","sourceRoot":"","sources":["../buidler.config.ts"],"names":[],"mappings":";;AAAA,sDAAoE;AAEpE,wDAGiC;AAEjC,kBAAS,CAAC,2BAA2B,CAAC,CAAA;AACtC,kBAAS,CAAC,2BAA2B,CAAC,CAAA;AAEtC,kDAA+C;AAE/C,MAAM,MAAM,GAAkB;IAC5B,QAAQ,EAAE;QACR,UAAU,EAAE;YACV,QAAQ,EAAE,oCAAwB;YAClC,aAAa,EAAE,4BAAgB,GAAG,CAAC;SACpC;KACF;IACD,KAAK,EAAE;QACL,OAAO,EAAE,KAAK;KACf;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,OAAO;QAChB,SAAS,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE;KACxC;CACF,CAAA;AAED,kBAAe,MAAM,CAAA"}
\ No newline at end of file
packages/contracts/build/contracts/OVM/accounts/OVM_ECDSAContractAccount.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Interface Imports */
import { iOVM_ECDSAContractAccount } from "../../iOVM/accounts/iOVM_ECDSAContractAccount.sol";
import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
import { Lib_ECDSAUtils } from "../../libraries/utils/Lib_ECDSAUtils.sol";
/**
* @title OVM_ECDSAContractAccount
*/
contract OVM_ECDSAContractAccount is iOVM_ECDSAContractAccount {
/********************
* Public Functions *
********************/
/**
* Executes a signed transaction.
* @param _transaction Signed EOA transaction.
* @param _signatureType Hashing scheme used for the transaction (e.g., ETH signed message).
* @param _v Signature `v` parameter.
* @param _r Signature `r` parameter.
* @param _s Signature `s` parameter.
* @return _success Whether or not the call returned (rather than reverted).
* @return _returndata Data returned by the call.
*/
function execute(
bytes memory _transaction,
Lib_OVMCodec.EOASignatureType _signatureType,
uint8 _v,
bytes32 _r,
bytes32 _s
)
override
public
returns (
bool _success,
bytes memory _returndata
)
{
iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
// Address of this contract within the ovm (ovmADDRESS) should be the same as the
// recovered address of the user who signed this message. This is how we manage to shim
// account abstraction even though the user isn't a contract.
require(
Lib_ECDSAUtils.recover(
_transaction,
_signatureType == Lib_OVMCodec.EOASignatureType.ETH_SIGNED_MESSAGE,
_v,
_r,
_s,
ovmExecutionManager.ovmCHAINID()
) == ovmExecutionManager.ovmADDRESS(),
"Signature provided for EOA transaction execution is invalid."
);
Lib_OVMCodec.EOATransaction memory decodedTx = Lib_OVMCodec.decodeEOATransaction(_transaction);
// Need to make sure that the transaction nonce is right and bump it if so.
require(
decodedTx.nonce == ovmExecutionManager.ovmGETNONCE() + 1,
"Transaction nonce does not match the expected nonce."
);
ovmExecutionManager.ovmSETNONCE(decodedTx.nonce);
// Contract creations are signalled by sending a transaction to the zero address.
if (decodedTx.target == address(0)) {
address created = ovmExecutionManager.ovmCREATE{gas: decodedTx.gasLimit}(
decodedTx.data
);
// EVM doesn't tell us whether a contract creation failed, even if it reverted during
// initialization. Always return `true` for our success value here.
return (true, abi.encode(created));
} else {
return ovmExecutionManager.ovmCALL(
decodedTx.gasLimit,
decodedTx.target,
decodedTx.data
);
}
}
}
packages/contracts/build/contracts/OVM/bridge/OVM_BaseCrossDomainMessenger.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Interface Imports */
import { iOVM_BaseCrossDomainMessenger } from "../../iOVM/bridge/iOVM_BaseCrossDomainMessenger.sol";
/**
* @title OVM_BaseCrossDomainMessenger
*/
contract OVM_BaseCrossDomainMessenger is iOVM_BaseCrossDomainMessenger {
/**********************
* Contract Variables *
**********************/
mapping (bytes32 => bool) public receivedMessages;
mapping (bytes32 => bool) public sentMessages;
address public targetMessengerAddress;
uint256 public messageNonce;
address public xDomainMessageSender;
/********************
* Public Functions *
********************/
/**
* Sets the target messenger address.
* @dev Currently, this function is public and therefore allows anyone to modify the target
* messenger for a given xdomain messenger contract. Obviously this shouldn't be allowed,
* but we still need to determine an adequate mechanism for updating this address.
* @param _targetMessengerAddress New messenger address.
*/
function setTargetMessengerAddress(
address _targetMessengerAddress
)
override
public
{
targetMessengerAddress = _targetMessengerAddress;
}
/**********************
* Internal Functions *
**********************/
/**
* Generates the correct cross domain calldata for a message.
* @param _target Target contract address.
* @param _sender Message sender address.
* @param _message Message to send to the target.
* @param _messageNonce Nonce for the provided message.
* @return ABI encoded cross domain calldata.
*/
function _getXDomainCalldata(
address _target,
address _sender,
bytes memory _message,
uint256 _messageNonce
)
internal
pure
returns (
bytes memory
)
{
return abi.encodeWithSelector(
bytes4(keccak256(bytes("relayMessage(address,address,bytes,uint256)"))),
_target,
_sender,
_message,
_messageNonce
);
}
}
packages/contracts/build/contracts/OVM/bridge/OVM_L1CrossDomainMessenger.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
import { Lib_EthMerkleTrie } from "../../libraries/trie/Lib_EthMerkleTrie.sol";
import { Lib_ByteUtils } from "../../libraries/utils/Lib_ByteUtils.sol";
/* Interface Imports */
import { iOVM_L1CrossDomainMessenger } from "../../iOVM/bridge/iOVM_L1CrossDomainMessenger.sol";
import { iOVM_L1ToL2TransactionQueue } from "../../iOVM/queue/iOVM_L1ToL2TransactionQueue.sol";
import { iOVM_StateCommitmentChain } from "../../iOVM/chain/iOVM_StateCommitmentChain.sol";
/* Contract Imports */
import { OVM_BaseCrossDomainMessenger } from "./OVM_BaseCrossDomainMessenger.sol";
/**
* @title OVM_L1CrossDomainMessenger
*/
contract OVM_L1CrossDomainMessenger is iOVM_L1CrossDomainMessenger, OVM_BaseCrossDomainMessenger, Lib_AddressResolver {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
iOVM_L1ToL2TransactionQueue internal ovmL1ToL2TransactionQueue;
iOVM_StateCommitmentChain internal ovmStateCommitmentChain;
/***************
* Constructor *
***************/
/**
* @param _libAddressManager Address of the Address Manager.
*/
constructor(
address _libAddressManager
)
Lib_AddressResolver(_libAddressManager)
{
ovmL1ToL2TransactionQueue = iOVM_L1ToL2TransactionQueue(resolve("OVM_L1ToL2TransactionQueue"));
ovmStateCommitmentChain = iOVM_StateCommitmentChain(resolve("OVM_StateCommitmentChain"));
}
/********************
* Public Functions *
********************/
/**
* Relays a cross domain message to a contract.
* @inheritdoc iOVM_L1CrossDomainMessenger
*/
function relayMessage(
address _target,
address _sender,
bytes memory _message,
uint256 _messageNonce,
L2MessageInclusionProof memory _proof
)
override
public
{
bytes memory xDomainCalldata = _getXDomainCalldata(
_target,
_sender,
_message,
_messageNonce
);
require(
_verifyXDomainMessage(
xDomainCalldata,
_proof
) == true,
"Provided message could not be verified."
);
require(
receivedMessages[keccak256(xDomainCalldata)] == false,
"Provided message has already been received."
);
xDomainMessageSender = _sender;
_target.call(_message);
// Messages are considered successfully executed if they complete
// without running out of gas (revert or not). As a result, we can
// ignore the result of the call and always mark the message as
// successfully executed because we won't get here unless we have
// enough gas left over.
receivedMessages[keccak256(xDomainCalldata)] = true;
}
/**
* Sends a cross domain message to the target messenger.
* @inheritdoc iOVM_L1CrossDomainMessenger
*/
function sendMessage(
address _target,
bytes memory _message,
uint32 _gasLimit
)
override
public
{
bytes memory xDomainCalldata = _getXDomainCalldata(
_target,
msg.sender,
_message,
messageNonce
);
_sendXDomainMessage(xDomainCalldata, _gasLimit);
messageNonce += 1;
sentMessages[keccak256(xDomainCalldata)] = true;
}
/**
* Replays a cross domain message to the target messenger.
* @inheritdoc iOVM_L1CrossDomainMessenger
*/
function replayMessage(
address _target,
address _sender,
bytes memory _message,
uint256 _messageNonce,
uint32 _gasLimit
)
override
public
{
bytes memory xDomainCalldata = _getXDomainCalldata(
_target,
_sender,
_message,
_messageNonce
);
require(
sentMessages[keccak256(xDomainCalldata)] == true,
"Provided message has not already been sent."
);
_sendXDomainMessage(xDomainCalldata, _gasLimit);
}
/**********************
* Internal Functions *
**********************/
/**
* Verifies that the given message is valid.
* @param _xDomainCalldata Calldata to verify.
* @param _proof Inclusion proof for the message.
* @return Whether or not the provided message is valid.
*/
function _verifyXDomainMessage(
bytes memory _xDomainCalldata,
L2MessageInclusionProof memory _proof
)
internal
returns (
bool
)
{
return (
_verifyStateRootProof(_proof)
&& _verifyStorageProof(_xDomainCalldata, _proof)
);
}
/**
* Verifies that the state root within an inclusion proof is valid.
* @param _proof Message inclusion proof.
* @return Whether or not the provided proof is valid.
*/
function _verifyStateRootProof(
L2MessageInclusionProof memory _proof
)
internal
returns (
bool
)
{
// TODO: We *must* verify that the batch timestamp is sufficiently old.
// However, this requires that we first add timestamps to state batches
// and account for that change in various tests. Change of that size is
// out of scope for this ticket, so "TODO" for now.
return ovmStateCommitmentChain.verifyElement(
abi.encodePacked(_proof.stateRoot),
_proof.stateRootBatchHeader,
_proof.stateRootProof
);
}
/**
* Verifies that the storage proof within an inclusion proof is valid.
* @param _xDomainCalldata Encoded message calldata.
* @param _proof Message inclusion proof.
* @return Whether or not the provided proof is valid.
*/
function _verifyStorageProof(
bytes memory _xDomainCalldata,
L2MessageInclusionProof memory _proof
)
internal
returns (
bool
)
{
bytes32 storageKey = keccak256(
Lib_ByteUtils.concat(
abi.encodePacked(keccak256(_xDomainCalldata)),
abi.encodePacked(uint256(0))
)
);
return Lib_EthMerkleTrie.proveAccountStorageSlotValue(
0x4200000000000000000000000000000000000000,
storageKey,
bytes32(uint256(1)),
_proof.stateTrieWitness,
_proof.storageTrieWitness,
_proof.stateRoot
);
}
/**
* Sends a cross domain message.
* @param _message Message to send.
* @param _gasLimit OVM gas limit for the message.
*/
function _sendXDomainMessage(
bytes memory _message,
uint32 _gasLimit
)
internal
{
ovmL1ToL2TransactionQueue.enqueue(
targetMessengerAddress,
_gasLimit,
_message
);
}
}
packages/contracts/build/contracts/OVM/bridge/OVM_L2CrossDomainMessenger.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
/* Interface Imports */
import { iOVM_L2CrossDomainMessenger } from "../../iOVM/bridge/iOVM_L2CrossDomainMessenger.sol";
import { iOVM_L1MessageSender } from "../../iOVM/precompiles/iOVM_L1MessageSender.sol";
import { iOVM_L2ToL1MessagePasser } from "../../iOVM/precompiles/iOVM_L2ToL1MessagePasser.sol";
/* Contract Imports */
import { OVM_BaseCrossDomainMessenger } from "./OVM_BaseCrossDomainMessenger.sol";
/**
* @title OVM_L2CrossDomainMessenger
*/
contract OVM_L2CrossDomainMessenger is iOVM_L2CrossDomainMessenger, OVM_BaseCrossDomainMessenger, Lib_AddressResolver {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
iOVM_L1MessageSender internal ovmL1MessageSender;
iOVM_L2ToL1MessagePasser internal ovmL2ToL1MessagePasser;
/***************
* Constructor *
***************/
/**
* @param _libAddressManager Address of the Address Manager.
*/
constructor(
address _libAddressManager
)
Lib_AddressResolver(_libAddressManager)
{
ovmL1MessageSender = iOVM_L1MessageSender(resolve("OVM_L1MessageSender"));
ovmL2ToL1MessagePasser = iOVM_L2ToL1MessagePasser(resolve("OVM_L2ToL1MessagePasser"));
}
/********************
* Public Functions *
********************/
/**
* Relays a cross domain message to a contract.
* @inheritdoc iOVM_L2CrossDomainMessenger
*/
function relayMessage(
address _target,
address _sender,
bytes memory _message,
uint256 _messageNonce
)
override
public
{
require(
_verifyXDomainMessage() == true,
"Provided message could not be verified."
);
bytes memory xDomainCalldata = _getXDomainCalldata(
_target,
_sender,
_message,
_messageNonce
);
require(
receivedMessages[keccak256(xDomainCalldata)] == false,
"Provided message has already been received."
);
xDomainMessageSender = _sender;
_target.call(_message);
// Messages are considered successfully executed if they complete
// without running out of gas (revert or not). As a result, we can
// ignore the result of the call and always mark the message as
// successfully executed because we won't get here unless we have
// enough gas left over.
receivedMessages[keccak256(xDomainCalldata)] = true;
}
/**
* Sends a cross domain message to the target messenger.
* @inheritdoc iOVM_L2CrossDomainMessenger
*/
function sendMessage(
address _target,
bytes memory _message,
uint256 _gasLimit
)
override
public
{
bytes memory xDomainCalldata = _getXDomainCalldata(
_target,
msg.sender,
_message,
messageNonce
);
_sendXDomainMessage(xDomainCalldata, _gasLimit);
messageNonce += 1;
sentMessages[keccak256(xDomainCalldata)] = true;
}
/**********************
* Internal Functions *
**********************/
/**
* Verifies that a received cross domain message is valid.
* @return _valid Whether or not the message is valid.
*/
function _verifyXDomainMessage()
internal
returns (
bool _valid
)
{
return (
ovmL1MessageSender.getL1MessageSender() == targetMessengerAddress
);
}
/**
* Sends a cross domain message.
* @param _message Message to send.
* @param _gasLimit Gas limit for the provided message.
*/
function _sendXDomainMessage(
bytes memory _message,
uint256 _gasLimit
)
internal
{
ovmL2ToL1MessagePasser.passMessageToL1(_message);
}
}
packages/contracts/build/contracts/OVM/chain/OVM_BaseChain.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Interface Imports */
import { iOVM_BaseChain } from "../../iOVM/chain/iOVM_BaseChain.sol";
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
import { Lib_MerkleUtils } from "../../libraries/utils/Lib_MerkleUtils.sol";
/**
* @title OVM_BaseChain
*/
contract OVM_BaseChain is iOVM_BaseChain {
/*******************************
* Contract Variables: Batches *
*******************************/
bytes32[] internal batches;
uint256 internal totalBatches;
uint256 internal totalElements;
/*************************************
* Public Functions: Batch Retrieval *
*************************************/
/**
* Gets the total number of submitted elements.
* @return _totalElements Total submitted elements.
*/
function getTotalElements()
override
public
view
returns (
uint256 _totalElements
)
{
return totalElements;
}
/**
* Gets the total number of submitted batches.
* @return _totalBatches Total submitted batches.
*/
function getTotalBatches()
override
public
view
returns (
uint256 _totalBatches
)
{
return totalBatches;
}
/****************************************
* Public Functions: Batch Verification *
****************************************/
/**
* Verifies an inclusion proof for a given element.
* @param _element Element to verify.
* @param _batchHeader Header of the batch in which this element was included.
* @param _proof Inclusion proof for the element.
* @return _verified Whether or not the element was included in the batch.
*/
function verifyElement(
bytes calldata _element,
Lib_OVMCodec.ChainBatchHeader memory _batchHeader,
Lib_OVMCodec.ChainInclusionProof memory _proof
)
override
public
view
returns (
bool _verified
)
{
require(
_hashBatchHeader(_batchHeader) == batches[_batchHeader.batchIndex],
"Invalid batch header."
);
require(
Lib_MerkleUtils.verify(
_batchHeader.batchRoot,
_element,
_proof.index,
_proof.siblings
),
"Invalid inclusion proof."
);
return true;
}
/******************************************
* Internal Functions: Batch Modification *
******************************************/
/**
* Appends a batch to the chain.
* @param _batchHeader Batch header to append.
*/
function _appendBatch(
Lib_OVMCodec.ChainBatchHeader memory _batchHeader
)
internal
{
bytes32 batchHeaderHash = _hashBatchHeader(_batchHeader);
batches.push(batchHeaderHash);
totalBatches += 1;
totalElements += _batchHeader.batchSize;
}
/**
* Appends a batch to the chain.
* @param _elements Elements within the batch.
* @param _extraData Any extra data to append to the batch.
*/
function _appendBatch(
bytes[] memory _elements,
bytes memory _extraData
)
internal
{
Lib_OVMCodec.ChainBatchHeader memory batchHeader = Lib_OVMCodec.ChainBatchHeader({
batchIndex: batches.length,
batchRoot: Lib_MerkleUtils.getMerkleRoot(_elements),
batchSize: _elements.length,
prevTotalElements: totalElements,
extraData: _extraData
});
_appendBatch(batchHeader);
}
/**
* Appends a batch to the chain.
* @param _elements Elements within the batch.
*/
function _appendBatch(
bytes[] memory _elements
)
internal
{
_appendBatch(
_elements,
bytes('')
);
}
/**
* Removes a batch from the chain.
* @param _batchHeader Header of the batch to remove.
*/
function _deleteBatch(
Lib_OVMCodec.ChainBatchHeader memory _batchHeader
)
internal
{
require(
_batchHeader.batchIndex < batches.length,
"Invalid batch index."
);
require(
_hashBatchHeader(_batchHeader) == batches[_batchHeader.batchIndex],
"Invalid batch header."
);
totalBatches = _batchHeader.batchIndex;
totalElements = _batchHeader.prevTotalElements;
}
/*********************
* Private Functions *
*********************/
/**
* Calculates a hash for a given batch header.
* @param _batchHeader Header to hash.
* @return _hash Hash of the header.
*/
function _hashBatchHeader(
Lib_OVMCodec.ChainBatchHeader memory _batchHeader
)
private
pure
returns (
bytes32 _hash
)
{
return keccak256(abi.encodePacked(
_batchHeader.batchRoot,
_batchHeader.batchSize,
_batchHeader.prevTotalElements,
_batchHeader.extraData
));
}
}
packages/contracts/build/contracts/OVM/chain/OVM_CanonicalTransactionChain.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
import { Lib_MerkleUtils } from "../../libraries/utils/Lib_MerkleUtils.sol";
/* Interface Imports */
import { iOVM_CanonicalTransactionChain } from "../../iOVM/chain/iOVM_CanonicalTransactionChain.sol";
import { iOVM_L1ToL2TransactionQueue } from "../../iOVM/queue/iOVM_L1ToL2TransactionQueue.sol";
/* Contract Imports */
import { OVM_BaseChain } from "./OVM_BaseChain.sol";
/**
* @title OVM_CanonicalTransactionChain
*/
contract OVM_CanonicalTransactionChain is iOVM_CanonicalTransactionChain, OVM_BaseChain, Lib_AddressResolver {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
iOVM_L1ToL2TransactionQueue internal ovmL1ToL2TransactionQueue;
/*******************************************
* Contract Variables: Internal Accounting *
*******************************************/
uint256 internal forceInclusionPeriodSeconds;
uint256 internal lastOVMTimestamp;
/***************
* Constructor *
***************/
/**
* @param _libAddressManager Address of the Address Manager.
* @param _forceInclusionPeriodSeconds Period during which only the sequencer can submit.
*/
constructor(
address _libAddressManager,
uint256 _forceInclusionPeriodSeconds
)
Lib_AddressResolver(_libAddressManager)
{
ovmL1ToL2TransactionQueue = iOVM_L1ToL2TransactionQueue(resolve("OVM_L1ToL2TransactionQueue"));
forceInclusionPeriodSeconds = _forceInclusionPeriodSeconds;
}
/****************************************
* Public Functions: Batch Manipulation *
****************************************/
/**
* Appends a batch from the L1ToL2TransactionQueue.
*/
function appendQueueBatch()
override
public
{
require(
ovmL1ToL2TransactionQueue.size() > 0,
"No batches are currently queued to be appended."
);
Lib_OVMCodec.QueueElement memory queueElement = ovmL1ToL2TransactionQueue.peek();
require(
queueElement.timestamp + forceInclusionPeriodSeconds <= block.timestamp,
"Cannot append until the inclusion delay period has elapsed."
);
_appendQueueBatch(queueElement, 1);
ovmL1ToL2TransactionQueue.dequeue();
}
/**
* Appends a sequencer batch.
* @param _batch Batch of transactions to append.
* @param _timestamp Timestamp for the provided batch.
*/
function appendSequencerBatch(
bytes[] memory _batch,
uint256 _timestamp
)
override
public
{
require(
msg.sender == resolve("Sequencer"),
"Function can only be called by the Sequencer."
);
require(
_batch.length > 0,
"Cannot submit an empty batch."
);
require(
_timestamp > lastOVMTimestamp,
"Batch timestamp must be later than the last OVM timestamp."
);
if (ovmL1ToL2TransactionQueue.size() > 0) {
require(
_timestamp <= ovmL1ToL2TransactionQueue.peek().timestamp,
"Older queue batches must be processed before a newer sequencer batch."
);
}
Lib_OVMCodec.QueueElement memory queueElement = Lib_OVMCodec.QueueElement({
timestamp: _timestamp,
batchRoot: Lib_MerkleUtils.getMerkleRoot(_batch),
isL1ToL2Batch: false
});
_appendQueueBatch(queueElement, _batch.length);
}
/******************************************
* Internal Functions: Batch Manipulation *
******************************************/
/**
* Appends a queue batch to the chain.
* @param _queueElement Queue element to append.
* @param _batchSize Number of elements in the batch.
*/
function _appendQueueBatch(
Lib_OVMCodec.QueueElement memory _queueElement,
uint256 _batchSize
)
internal
{
Lib_OVMCodec.ChainBatchHeader memory batchHeader = Lib_OVMCodec.ChainBatchHeader({
batchIndex: getTotalBatches(),
batchRoot: _queueElement.batchRoot,
batchSize: _batchSize,
prevTotalElements: getTotalElements(),
extraData: abi.encodePacked(
_queueElement.timestamp,
_queueElement.isL1ToL2Batch
)
});
_appendBatch(batchHeader);
lastOVMTimestamp = _queueElement.timestamp;
}
}
packages/contracts/build/contracts/OVM/chain/OVM_StateCommitmentChain.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
/* Interface Imports */
import { iOVM_FraudVerifier } from "../../iOVM/verification/iOVM_FraudVerifier.sol";
import { iOVM_StateCommitmentChain } from "../../iOVM/chain/iOVM_StateCommitmentChain.sol";
import { iOVM_CanonicalTransactionChain } from "../../iOVM/chain/iOVM_CanonicalTransactionChain.sol";
/* Contract Imports */
import { OVM_BaseChain } from "./OVM_BaseChain.sol";
/**
* @title OVM_StateCommitmentChain
*/
contract OVM_StateCommitmentChain is iOVM_StateCommitmentChain, OVM_BaseChain, Lib_AddressResolver {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
iOVM_CanonicalTransactionChain internal ovmCanonicalTransactionChain;
iOVM_FraudVerifier internal ovmFraudVerifier;
/***************
* Constructor *
***************/
/**
* @param _libAddressManager Address of the Address Manager.
*/
constructor(
address _libAddressManager
)
Lib_AddressResolver(_libAddressManager)
{
ovmCanonicalTransactionChain = iOVM_CanonicalTransactionChain(resolve("OVM_CanonicalTransactionChain"));
ovmFraudVerifier = iOVM_FraudVerifier(resolve("OVM_FraudVerifier"));
}
/****************************************
* Public Functions: Batch Manipulation *
****************************************/
/**
* Appends a batch of state roots to the chain.
* @param _batch Batch of state roots.
*/
function appendStateBatch(
bytes32[] memory _batch
)
override
public
{
require(
_batch.length > 0,
"Cannot submit an empty state batch."
);
require(
getTotalElements() + _batch.length <= ovmCanonicalTransactionChain.getTotalElements(),
"Number of state roots cannot exceed the number of canonical transactions."
);
bytes[] memory elements = new bytes[](_batch.length);
for (uint256 i = 0; i < _batch.length; i++) {
elements[i] = abi.encodePacked(_batch[i]);
}
_appendBatch(elements);
}
/**
* Deletes all state roots after (and including) a given batch.
* @param _batchHeader Header of the batch to start deleting from.
*/
function deleteStateBatch(
Lib_OVMCodec.ChainBatchHeader memory _batchHeader
)
override
public
{
require(
msg.sender == address(ovmFraudVerifier),
"State batches can only be deleted by the OVM_FraudVerifier."
);
_deleteBatch(_batchHeader);
}
}
packages/contracts/build/contracts/OVM/execution/OVM_ExecutionManager.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
import { Lib_EthUtils } from "../../libraries/utils/Lib_EthUtils.sol";
/* Interface Imports */
import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
import { iOVM_StateManager } from "../../iOVM/execution/iOVM_StateManager.sol";
import { iOVM_SafetyChecker } from "../../iOVM/execution/iOVM_SafetyChecker.sol";
/* Contract Imports */
import { OVM_ECDSAContractAccount } from "../accounts/OVM_ECDSAContractAccount.sol";
/* Logging */
import { console } from "@nomiclabs/buidler/console.sol";
/**
* @title OVM_ExecutionManager
*/
contract OVM_ExecutionManager is iOVM_ExecutionManager {
/********************************
* External Contract References *
********************************/
iOVM_SafetyChecker public ovmSafetyChecker;
iOVM_StateManager public ovmStateManager;
/*******************************
* Execution Context Variables *
*******************************/
GasMeterConfig internal gasMeterConfig;
GlobalContext internal globalContext;
TransactionContext internal transactionContext;
MessageContext internal messageContext;
TransactionRecord internal transactionRecord;
MessageRecord internal messageRecord;
/**************************
* Gas Metering Constants *
**************************/
address constant GAS_METADATA_ADDRESS = 0x06a506A506a506A506a506a506A506A506A506A5;
uint256 constant NUISANCE_GAS_SLOAD = 20000;
uint256 constant NUISANCE_GAS_SSTORE = 20000;
uint256 constant MIN_NUISANCE_GAS_PER_CONTRACT = 30000;
uint256 constant NUISANCE_GAS_PER_CONTRACT_BYTE = 100;
uint256 constant MIN_GAS_FOR_INVALID_STATE_ACCESS = 30000;
/***************
* Constructor *
***************/
/**
* @param _ovmSafetyChecker Address of the iOVM_SafetyChecker implementation.
*/
constructor(
address _ovmSafetyChecker
) {
ovmSafetyChecker = iOVM_SafetyChecker(_ovmSafetyChecker);
}
/**********************
* Function Modifiers *
**********************/
/**
* Applies a net gas cost refund to a transaction to account for the difference in execution
* between L1 and L2.
* @param _cost Gas cost for the function after the refund.
*/
modifier netGasCost(
uint256 _cost
) {
uint256 gasProvided = gasleft();
_;
uint256 gasUsed = gasProvided - gasleft();
// We want to refund everything *except* the specified cost.
if (_cost < gasUsed) {
transactionRecord.ovmGasRefund += gasUsed - _cost;
}
}
/**
* Makes sure we're not inside a static context.
*/
modifier notStatic() {
if (messageContext.isStatic == true) {
_revertWithFlag(RevertFlag.STATIC_VIOLATION);
}
_;
}
/************************************
* Transaction Execution Entrypoint *
************************************/
/**
* Starts the execution of a transaction via the OVM_ExecutionManager.
* @param _transaction Transaction data to be executed.
* @param _ovmStateManager iOVM_StateManager implementation providing account state.
*/
function run(
Lib_OVMCodec.Transaction memory _transaction,
address _ovmStateManager
)
override
public
{
// Store our OVM_StateManager instance (significantly easier than attempting to pass the address
// around in calldata).
ovmStateManager = iOVM_StateManager(_ovmStateManager);
// Check whether we need to start a new epoch, do so if necessary.
_checkNeedsNewEpoch(_transaction.timestamp);
// Make sure the transaction's gas limit is valid. We don't revert here because we reserve
// reverts for INVALID_STATE_ACCESS.
if (_isValidGasLimit(_transaction.gasLimit, _transaction.l1QueueOrigin) == false) {
return;
}
// Initialize the execution context.
_initContext(_transaction);
// Run the transaction, make sure to meter the gas usage.
uint256 gasProvided = gasleft();
ovmCALL(
_transaction.gasLimit - gasMeterConfig.minTransactionGasLimit,
_transaction.entrypoint,
_transaction.data
);
uint256 gasUsed = gasProvided - gasleft();
// Update the cumulative gas based on the amount of gas used.
_updateCumulativeGas(gasUsed, _transaction.l1QueueOrigin);
// Wipe the execution context.
_resetContext();
}
/******************************
* Opcodes: Execution Context *
******************************/
/**
* @notice Overrides CALLER.
* @return _CALLER Address of the CALLER within the current message context.
*/
function ovmCALLER()
override
public
view
returns (
address _CALLER
)
{
return messageContext.ovmCALLER;
}
/**
* @notice Overrides ADDRESS.
* @return _ADDRESS Active ADDRESS within the current message context.
*/
function ovmADDRESS()
override
public
view
returns (
address _ADDRESS
)
{
return messageContext.ovmADDRESS;
}
/**
* @notice Overrides TIMESTAMP.
* @return _TIMESTAMP Value of the TIMESTAMP within the transaction context.
*/
function ovmTIMESTAMP()
override
public
view
returns (
uint256 _TIMESTAMP
)
{
return transactionContext.ovmTIMESTAMP;
}
/**
* @notice Overrides NUMBER.
* @return _NUMBER Value of the NUMBER within the transaction context.
*/
function ovmNUMBER()
override
public
view
returns (
uint256 _NUMBER
)
{
return transactionContext.ovmNUMBER;
}
/**
* @notice Overrides GASLIMIT.
* @return _GASLIMIT Value of the block's GASLIMIT within the transaction context.
*/
function ovmGASLIMIT()
override
public
view
returns (
uint256 _GASLIMIT
)
{
return transactionContext.ovmGASLIMIT;
}
/**
* @notice Overrides CHAINID.
* @return _CHAINID Value of the chain's CHAINID within the global context.
*/
function ovmCHAINID()
override
public
view
returns (
uint256 _CHAINID
)
{
return globalContext.ovmCHAINID;
}
/*********************************
* Opcodes: L2 Execution Context *
*********************************/
/**
* @notice Specifies from which L1 rollup queue this transaction originated from.
* @return _queueOrigin Address of the CALLER within the current message context.
*/
function ovmL1QUEUEORIGIN()
override
public
view
returns (
Lib_OVMCodec.QueueOrigin _queueOrigin
)
{
return transactionContext.ovmL1QUEUEORIGIN;
}
/**
* @notice Specifies what L1 EOA, if any, sent this transaction.
* @return _l1TxOrigin Address of the EOA which send the tx into L2 from L1.
*/
function ovmL1TXORIGIN()
override
public
view
returns (
address _l1TxOrigin
)
{
return transactionContext.ovmL1TXORIGIN;
}
/********************
* Opcodes: Halting *
********************/
/**
* @notice Overrides REVERT.
* @param _data Bytes data to pass along with the REVERT.
*/
function ovmREVERT(
bytes memory _data
)
override
public
{
_revertWithFlag(RevertFlag.INTENTIONAL_REVERT, _data);
}
/******************************
* Opcodes: Contract Creation *
******************************/
/**
* @notice Overrides CREATE.
* @param _bytecode Code to be used to CREATE a new contract.
* @return _contract Address of the created contract.
*/
function ovmCREATE(
bytes memory _bytecode
)
override
public
notStatic
netGasCost(40000 + _bytecode.length * 100)
returns (
address _contract
)
{
// Creator is always the current ADDRESS.
address creator = ovmADDRESS();
// Generate the correct CREATE address.
address contractAddress = Lib_EthUtils.getAddressForCREATE(
creator,
_getAccountNonce(creator)
);
return _createContract(
contractAddress,
_bytecode
);
}
/**
* @notice Overrides CREATE2.
* @param _bytecode Code to be used to CREATE2 a new contract.
* @param _salt Value used to determine the contract's address.
* @return _contract Address of the created contract.
*/
function ovmCREATE2(
bytes memory _bytecode,
bytes32 _salt
)
override
public
notStatic
netGasCost(40000 + _bytecode.length * 100)
returns (
address _contract
)
{
// Creator is always the current ADDRESS.
address creator = ovmADDRESS();
// Generate the correct CREATE2 address.
address contractAddress = Lib_EthUtils.getAddressForCREATE2(
creator,
_bytecode,
_salt
);
return _createContract(
contractAddress,
_bytecode
);
}
/*******************************
* Account Abstraction Opcodes *
******************************/
/**
* Retrieves the nonce of the current ovmADDRESS.
* @return _nonce Nonce of the current contract.
*/
function ovmGETNONCE()
override
public
returns (
uint256 _nonce
)
{
return _getAccountNonce(ovmADDRESS());
}
/**
* Sets the nonce of the current ovmADDRESS.
* @param _nonce New nonce for the current contract.
*/
function ovmSETNONCE(
uint256 _nonce
)
override
public
{
if (_nonce <= ovmGETNONCE()) {
return;
}
_setAccountNonce(ovmADDRESS(), _nonce);
}
/**
* Creates a new EOA contract account, for account abstraction.
* @dev Essentially functions like ovmCREATE or ovmCREATE2, but we can bypass a lot of checks
* because the contract we're creating is trusted (no need to do safety checking or to
* handle unexpected reverts). Doesn't need to return an address because the address is
* assumed to be the user's actual address.
* @param _messageHash Hash of a message signed by some user, for verification.
* @param _v Signature `v` parameter.
* @param _r Signature `r` parameter.
* @param _s Signature `s` parameter.
*/
function ovmCREATEEOA(
bytes32 _messageHash,
uint8 _v,
bytes32 _r,
bytes32 _s
)
override
public
notStatic
{
// Recover the EOA address from the message hash and signature parameters. Since we do the
// hashing in advance, we don't have handle different message hashing schemes. Even if this
// function were to return the wrong address (rather than explicitly returning the zero
// address), the rest of the transaction would simply fail (since there's no EOA account to
// actually execute the transaction).
address eoa = ecrecover(
_messageHash,
(_v - uint8(ovmCHAINID()) * 2) - 8,
_r,
_s
);
// Invalid signature is a case we proactively handle with a revert. We could alternatively
// have this function return a `success` boolean, but this is just easier.
if (eoa == address(0)) {
ovmREVERT(bytes("Signature provided for EOA contract creation is invalid."));
}
// If the user already has an EOA account, then there's no need to perform this operation.
if (_hasEmptyAccount(eoa) == false) {
return;
}
// We always need to initialize the contract with the default account values.
_initPendingAccount(eoa);
// Now actually create the account and get its bytecode. We're not worried about reverts
// (other than out of gas, which we can't capture anyway) because this contract is trusted.
OVM_ECDSAContractAccount eoaContractAccount = new OVM_ECDSAContractAccount();
bytes memory deployedCode = Lib_EthUtils.getCode(address(eoaContractAccount));
// Commit the account with its final values.
_commitPendingAccount(
eoa,
address(eoaContractAccount),
keccak256(deployedCode)
);
}
/*********************************
* Opcodes: Contract Interaction *
*********************************/
/**
* @notice Overrides CALL.
* @param _gasLimit Amount of gas to be passed into this call.
* @param _address Address of the contract to call.
* @param _calldata Data to send along with the call.
* @return _success Whether or not the call returned (rather than reverted).
* @return _returndata Data returned by the call.
*/
function ovmCALL(
uint256 _gasLimit,
address _address,
bytes memory _calldata
)
override
public
netGasCost(100000)
returns (
bool _success,
bytes memory _returndata
)
{
// CALL updates the CALLER and ADDRESS.
MessageContext memory nextMessageContext = messageContext;
nextMessageContext.ovmCALLER = nextMessageContext.ovmADDRESS;
nextMessageContext.ovmADDRESS = _address;
nextMessageContext.isCreation = false;
bool isStaticEntrypoint = false;
return _callContract(
nextMessageContext,
_gasLimit,
_address,
_calldata,
isStaticEntrypoint
);
}
/**
* @notice Overrides STATICCALL.
* @param _gasLimit Amount of gas to be passed into this call.
* @param _address Address of the contract to call.
* @param _calldata Data to send along with the call.
* @return _success Whether or not the call returned (rather than reverted).
* @return _returndata Data returned by the call.
*/
function ovmSTATICCALL(
uint256 _gasLimit,
address _address,
bytes memory _calldata
)
override
public
netGasCost(80000)
returns (
bool _success,
bytes memory _returndata
)
{
// STATICCALL updates the CALLER, updates the ADDRESS, and runs in a static context.
MessageContext memory nextMessageContext = messageContext;
nextMessageContext.ovmCALLER = nextMessageContext.ovmADDRESS;
nextMessageContext.ovmADDRESS = _address;
nextMessageContext.isStatic = true;
nextMessageContext.isCreation = false;
bool isStaticEntrypoint = true;
return _callContract(
nextMessageContext,
_gasLimit,
_address,
_calldata,
isStaticEntrypoint
);
}
/**
* @notice Overrides DELEGATECALL.
* @param _gasLimit Amount of gas to be passed into this call.
* @param _address Address of the contract to call.
* @param _calldata Data to send along with the call.
* @return _success Whether or not the call returned (rather than reverted).
* @return _returndata Data returned by the call.
*/
function ovmDELEGATECALL(
uint256 _gasLimit,
address _address,
bytes memory _calldata
)
override
public
netGasCost(40000)
returns (
bool _success,
bytes memory _returndata
)
{
// DELEGATECALL does not change anything about the message context.
MessageContext memory nextMessageContext = messageContext;
nextMessageContext.isCreation = false;
bool isStaticEntrypoint = false;
return _callContract(
nextMessageContext,
_gasLimit,
_address,
_calldata,
isStaticEntrypoint
);
}
/************************************
* Opcodes: Contract Storage Access *
************************************/
/**
* @notice Overrides SLOAD.
* @param _key 32 byte key of the storage slot to load.
* @return _value 32 byte value of the requested storage slot.
*/
function ovmSLOAD(
bytes32 _key
)
override
public
netGasCost(40000)
returns (
bytes32 _value
)
{
// We always SLOAD from the storage of ADDRESS.
address contractAddress = ovmADDRESS();
return _getContractStorage(
contractAddress,
_key
);
}
/**
* @notice Overrides SSTORE.
* @param _key 32 byte key of the storage slot to set.
* @param _value 32 byte value for the storage slot.
*/
function ovmSSTORE(
bytes32 _key,
bytes32 _value
)
override
public
notStatic
netGasCost(60000)
{
// We always SSTORE to the storage of ADDRESS.
address contractAddress = ovmADDRESS();
_putContractStorage(
contractAddress,
_key,
_value
);
}
/*********************************
* Opcodes: Contract Code Access *
*********************************/
/**
* @notice Overrides EXTCODECOPY.
* @param _contract Address of the contract to copy code from.
* @param _offset Offset in bytes from the start of contract code to copy beyond.
* @param _length Total number of bytes to copy from the contract's code.
* @return _code Bytes of code copied from the requested contract.
*/
function ovmEXTCODECOPY(
address _contract,
uint256 _offset,
uint256 _length
)
override
public
returns (
bytes memory _code
)
{
// `ovmEXTCODECOPY` is the only overridden opcode capable of producing exactly one byte of
// return data. By blocking reads of one byte, we're able to use the condition that an
// OVM_ExecutionManager function return value having a length of exactly one byte indicates
// an error without an explicit revert. If users were able to read a single byte, they
// could forcibly trigger behavior that should only be available to this contract.
uint256 length = _length == 1 ? 2 : _length;
return Lib_EthUtils.getCode(
_getAccountEthAddress(_contract),
_offset,
length
);
}
/**
* @notice Overrides EXTCODESIZE.
* @param _contract Address of the contract to query the size of.
* @return _EXTCODESIZE Size of the requested contract in bytes.
*/
function ovmEXTCODESIZE(
address _contract
)
override
public
returns (
uint256 _EXTCODESIZE
)
{
return Lib_EthUtils.getCodeSize(
_getAccountEthAddress(_contract)
);
}
/**
* @notice Overrides EXTCODEHASH.
* @param _contract Address of the contract to query the hash of.
* @return _EXTCODEHASH Size of the requested contract in bytes.
*/
function ovmEXTCODEHASH(
address _contract
)
override
public
returns (
bytes32 _EXTCODEHASH
)
{
return Lib_EthUtils.getCodeHash(
_getAccountEthAddress(_contract)
);
}
/**************************************
* Public Functions: Execution Safety *
**************************************/
/**
* Performs the logic to create a contract and revert under various potential conditions.
* @dev This function is implemented as `public` because we need to be able to revert a
* contract creation without losing information about exactly *why* the contract reverted.
* In particular, we want to be sure that contracts cannot trigger an INVALID_STATE_ACCESS
* flag and then revert to reset the flag. We're able to do this by making an external
* call from `ovmCREATE` and `ovmCREATE2` to `safeCREATE`, which can capture and relay
* information before reverting.
* @param _address Address of the contract to associate with the one being created.
* @param _bytecode Code to be used to create the new contract.
*/
function safeCREATE(
address _address,
bytes memory _bytecode
)
override
public
{
// Since this function is public, anyone can attempt to directly call it. We need to make
// sure that the OVM_ExecutionManager itself is the only party that can actually try to
// call this function.
if (msg.sender != address(this)) {
return;
}
// We need to be sure that the user isn't trying to use a contract creation to overwrite
// some existing contract. On L1, users will prove that no contract exists at the address
// and the OVM_FraudVerifier will populate the code hash of this address with a special
// value that represents "known to be an empty account."
if (_hasEmptyAccount(_address) == false) {
_revertWithFlag(RevertFlag.CREATE_COLLISION);
}
// Check the creation bytecode against the OVM_SafetyChecker.
if (ovmSafetyChecker.isBytecodeSafe(_bytecode) == false) {
_revertWithFlag(RevertFlag.UNSAFE_BYTECODE);
}
// We always need to initialize the contract with the default account values.
_initPendingAccount(_address);
// We're going into a contract creation, so we need to set this flag to get the correct
// revert behavior.
messageContext.isCreation = true;
// Actually deploy the contract and retrieve its address. This step is hiding a lot of
// complexity because we need to ensure that contract creation *never* reverts by itself.
// We cover this partially by storing a revert flag and returning (instead of reverting)
// when we know that we're inside a contract's creation code.
address ethAddress = Lib_EthUtils.createContract(_bytecode);
// Now reset this flag so we go back to normal revert behavior.
messageContext.isCreation = false;
// Contract creation returns the zero address when it fails, which should only be possible
// if the user intentionally runs out of gas. However, we might still have a bit of gas
// left over since contract calls can only be passed 63/64ths of total gas, so we need to
// explicitly handle this case here.
if (ethAddress == address(0)) {
_revertWithFlag(RevertFlag.CREATE_EXCEPTION);
}
// Here we pull out the revert flag that would've been set during creation code. Now that
// we're out of creation code again, we can just revert normally while passing the flag
// through the revert data.
if (messageRecord.revertFlag != RevertFlag.DID_NOT_REVERT) {
_revertWithFlag(messageRecord.revertFlag);
}
// Again simply checking that the deployed code is safe too. Contracts can generate
// arbitrary deployment code, so there's no easy way to analyze this beforehand.
bytes memory deployedCode = Lib_EthUtils.getCode(ethAddress);
if (ovmSafetyChecker.isBytecodeSafe(deployedCode) == false) {
_revertWithFlag(RevertFlag.UNSAFE_BYTECODE);
}
// Contract creation didn't need to be reverted and the bytecode is safe. We finish up by
// associating the desired address with the newly created contract's code hash and address.
_commitPendingAccount(
_address,
ethAddress,
keccak256(deployedCode)
);
}
/********************************************
* Internal Functions: Contract Interaction *
********************************************/
/**
* Creates a new contract and associates it with some contract address.
* @param _contractAddress Address to associate the created contract with.
* @param _bytecode Bytecode to be used to create the contract.
* @return _created Final OVM contract address.
*/
function _createContract(
address _contractAddress,
bytes memory _bytecode
)
internal
returns (
address _created
)
{
// We always update the nonce of the creating account, even if the creation fails.
_setAccountNonce(ovmADDRESS(), 1);
// We're stepping into a CREATE or CREATE2, so we need to update ADDRESS to point
// to the contract's associated address and CALLER to point to the previous ADDRESS.
MessageContext memory nextMessageContext = messageContext;
nextMessageContext.ovmCALLER = messageContext.ovmADDRESS;
nextMessageContext.ovmADDRESS = _contractAddress;
// Run `safeCREATE` in a new EVM message so that our changes can be reflected even if
// `safeCREATE` reverts.
(bool _success, ) = _handleExternalInteraction(
nextMessageContext,
gasleft(),
address(this),
abi.encodeWithSignature(
"safeCREATE(address,bytes)",
_contractAddress,
_bytecode
),
false
);
// Need to make sure that this flag is reset so that it isn't propagated to creations in
// some parent EVM message.
messageRecord.revertFlag = RevertFlag.DID_NOT_REVERT;
// Yellow paper requires that address returned is zero if the contract deployment fails.
return _success ? _contractAddress : address(0);
}
/**
* Calls the deployed contract associated with a given address.
* @param _nextMessageContext Message context to be used for the call.
* @param _gasLimit Amount of gas to be passed into this call.
* @param _contract Address used to resolve the deployed contract.
* @param _calldata Data to send along with the call.
* @param _isStaticEntrypoint Whether or not this is coming from ovmSTATICCALL.
* @return _success Whether or not the call returned (rather than reverted).
* @return _returndata Data returned by the call.
*/
function _callContract(
MessageContext memory _nextMessageContext,
uint256 _gasLimit,
address _contract,
bytes memory _calldata,
bool _isStaticEntrypoint
)
internal
returns (
bool _success,
bytes memory _returndata
)
{
return _handleExternalInteraction(
_nextMessageContext,
_gasLimit,
_getAccountEthAddress(_contract),
_calldata,
_isStaticEntrypoint
);
}
/**
* Handles the logic of making an external call and parsing revert information.
* @param _nextMessageContext Message context to be used for the call.
* @param _gasLimit Amount of gas to be passed into this call.
* @param _target Address of the contract to call.
* @param _data Data to send along with the call.
* @param _isStaticEntrypoint Whether or not this is coming from ovmSTATICCALL.
* @return _success Whether or not the call returned (rather than reverted).
* @return _returndata Data returned by the call.
*/
function _handleExternalInteraction(
MessageContext memory _nextMessageContext,
uint256 _gasLimit,
address _target,
bytes memory _data,
bool _isStaticEntrypoint
)
internal
returns (
bool _success,
bytes memory _returndata
)
{
// We need to switch over to our next message context for the duration of this call.
MessageContext memory prevMessageContext = messageContext;
_switchMessageContext(prevMessageContext, _nextMessageContext);
// Nuisance gas is a system used to bound the ability for an attacker to make fraud proofs
// expensive by touching a lot of different accounts or storage slots. Since most contracts
// only use a few storage slots during any given transaction, this shouldn't be a limiting
// factor.
uint256 prevNuisanceGasLeft = messageRecord.nuisanceGasLeft;
uint256 nuisanceGasLimit = _getNuisanceGasLimit(_gasLimit);
messageRecord.nuisanceGasLeft = nuisanceGasLimit;
// Make the call and make sure to pass in the gas limit. Another instance of hidden
// complexity. `_target` is guaranteed to be a safe contract, meaning its return/revert
// behavior can be controlled. In particular, we enforce that flags are passed through
// revert data as to retrieve execution metadata that would normally be reverted out of
// existence.
(bool success, bytes memory returndata) = _target.call{gas: _gasLimit}(_data);
// Switch back to the original message context now that we're out of the call.
_switchMessageContext(_nextMessageContext, prevMessageContext);
// Assuming there were no reverts, the message record should be accurate here. We'll update
// this value in the case of a revert.
uint256 nuisanceGasLeft = messageRecord.nuisanceGasLeft;
// Reverts at this point are completely OK, but we need to make a few updates based on the
// information passed through the revert.
if (success == false) {
(
RevertFlag flag,
uint256 nuisanceGasLeftPostRevert,
uint256 ovmGasRefund,
bytes memory returndataFromFlag
) = _decodeRevertData(returndata);
// INVALID_STATE_ACCESS is the only flag that triggers an immediate abort of the
// parent EVM message. This behavior is necessary because INVALID_STATE_ACCESS must
// halt any further transaction execution that could impact the execution result.
if (flag == RevertFlag.INVALID_STATE_ACCESS) {
_revertWithFlag(flag);
}
// STATIC_VIOLATION should be passed all the way back up to the previous ovmSTATICCALL
// in the call stack.
if (
flag == RevertFlag.STATIC_VIOLATION
&& _isStaticEntrypoint == false
) {
_revertWithFlag(flag);
}
// INTENTIONAL_REVERT and UNSAFE_BYTECODE aren't dependent on the input state, so we
// can just handle them like standard reverts. Our only change here is to record the
// gas refund reported by the call (enforced by safety checking).
if (
flag == RevertFlag.INTENTIONAL_REVERT
|| flag == RevertFlag.UNSAFE_BYTECODE
) {
transactionRecord.ovmGasRefund = ovmGasRefund;
}
// INTENTIONAL_REVERT needs to pass up the user-provided return data encoded into the
// flag, *not* the full encoded flag. All other revert types return no data.
if (flag == RevertFlag.INTENTIONAL_REVERT) {
returndata = returndataFromFlag;
} else {
returndata = hex'';
}
// Reverts mean we need to use up whatever "nuisance gas" was used by the call.
// EXCEEDS_NUISANCE_GAS explicitly reduces the remaining nuisance gas for this message
// to zero. OUT_OF_GAS is a "pseudo" flag given that messages return no data when they
// run out of gas, so we have to treat this like EXCEEDS_NUISANCE_GAS. All other flags
// will simply pass up the remaining nuisance gas.
nuisanceGasLeft = nuisanceGasLeftPostRevert;
}
// We need to reset the nuisance gas back to its original value minus the amount used here.
messageRecord.nuisanceGasLeft = prevNuisanceGasLeft - (nuisanceGasLimit - nuisanceGasLeft);
return (
success,
returndata
);
}
/******************************************
* Internal Functions: State Manipulation *
******************************************/
/**
* Checks whether an account exists within the OVM_StateManager.
* @param _address Address of the account to check.
* @return _exists Whether or not the account exists.
*/
function _hasAccount(
address _address
)
internal
returns (
bool _exists
)
{
_checkAccountLoad(_address);
return ovmStateManager.hasAccount(_address);
}
/**
* Checks whether a known empty account exists within the OVM_StateManager.
* @param _address Address of the account to check.
* @return _exists Whether or not the account empty exists.
*/
function _hasEmptyAccount(
address _address
)
internal
returns (
bool _exists
)
{
_checkAccountLoad(_address);
return ovmStateManager.hasEmptyAccount(_address);
}
/**
* Sets the nonce of an account.
* @param _address Address of the account to modify.
* @param _nonce New account nonce.
*/
function _setAccountNonce(
address _address,
uint256 _nonce
)
internal
{
_checkAccountChange(_address);
ovmStateManager.setAccountNonce(_address, _nonce);
}
/**
* Gets the nonce of an account.
* @param _address Address of the account to access.
* @return _nonce Nonce of the account.
*/
function _getAccountNonce(
address _address
)
internal
returns (
uint256 _nonce
)
{
_checkAccountLoad(_address);
return ovmStateManager.getAccountNonce(_address);
}
/**
* Retrieves the Ethereum address of an account.
* @param _address Address of the account to access.
* @return _ethAddress Corresponding Ethereum address.
*/
function _getAccountEthAddress(
address _address
)
internal
returns (
address _ethAddress
)
{
_checkAccountLoad(_address);
return ovmStateManager.getAccountEthAddress(_address);
}
/**
* Creates the default account object for the given address.
* @param _address Address of the account create.
*/
function _initPendingAccount(
address _address
)
internal
{
// Although it seems like `_checkAccountChange` would be more appropriate here, we don't
// actually consider an account "changed" until it's inserted into the state (in this case
// by `_commitPendingAccount`).
_checkAccountLoad(_address);
ovmStateManager.initPendingAccount(_address);
}
/**
* Stores additional relevant data for a new account, thereby "committing" it to the state.
* This function is only called during `ovmCREATE` and `ovmCREATE2` after a successful contract
* creation.
* @param _address Address of the account to commit.
* @param _ethAddress Address of the associated deployed contract.
* @param _codeHash Hash of the code stored at the address.
*/
function _commitPendingAccount(
address _address,
address _ethAddress,
bytes32 _codeHash
)
internal
{
_checkAccountChange(_address);
ovmStateManager.commitPendingAccount(
_address,
_ethAddress,
_codeHash
);
}
/**
* Retrieves the value of a storage slot.
* @param _contract Address of the contract to query.
* @param _key 32 byte key of the storage slot.
* @return _value 32 byte storage slot value.
*/
function _getContractStorage(
address _contract,
bytes32 _key
)
internal
returns (
bytes32 _value
)
{
_checkContractStorageLoad(_contract, _key);
return ovmStateManager.getContractStorage(_contract, _key);
}
/**
* Sets the value of a storage slot.
* @param _contract Address of the contract to modify.
* @param _key 32 byte key of the storage slot.
* @param _value 32 byte storage slot value.
*/
function _putContractStorage(
address _contract,
bytes32 _key,
bytes32 _value
)
internal
{
_checkContractStorageChange(_contract, _key);
ovmStateManager.putContractStorage(_contract, _key, _value);
}
/**
* Validation whenever a contract needs to be loaded. Checks that the account exists, charges
* nuisance gas if the account hasn't been loaded before.
* @param _address Address of the account to load.
*/
function _checkAccountLoad(
address _address
)
internal
{
// See `_checkContractStorageLoad` for more information.
if (gasleft() < MIN_GAS_FOR_INVALID_STATE_ACCESS) {
_revertWithFlag(RevertFlag.OUT_OF_GAS);
}
// See `_checkContractStorageLoad` for more information.
if (ovmStateManager.hasAccount(_address) == false) {
_revertWithFlag(RevertFlag.INVALID_STATE_ACCESS);
}
// Check whether the account has been loaded before and mark it as loaded if not. We need
// this because "nuisance gas" only applies to the first time that an account is loaded.
(
bool _wasAccountAlreadyLoaded
) = ovmStateManager.testAndSetAccountLoaded(_address);
// If we hadn't already loaded the account, then we'll need to charge "nuisance gas" based
// on the size of the contract code.
if (_wasAccountAlreadyLoaded == false) {
_useNuisanceGas(
(Lib_EthUtils.getCodeSize(_getAccountEthAddress(_address)) * NUISANCE_GAS_PER_CONTRACT_BYTE) + MIN_NUISANCE_GAS_PER_CONTRACT
);
}
}
/**
* Validation whenever a contract needs to be changed. Checks that the account exists, charges
* nuisance gas if the account hasn't been changed before.
* @param _address Address of the account to change.
*/
function _checkAccountChange(
address _address
)
internal
{
// Check whether the account has been changed before and mark it as changed if not. We need
// this because "nuisance gas" only applies to the first time that an account is changed.
(
bool _wasAccountAlreadyChanged
) = ovmStateManager.testAndSetAccountChanged(_address);
// If we hadn't already changed the account, then we'll need to charge "nuisance gas" based
// on the size of the contract code.
if (_wasAccountAlreadyChanged == false) {
ovmStateManager.incrementTotalUncommittedAccounts();
_useNuisanceGas(
(Lib_EthUtils.getCodeSize(_getAccountEthAddress(_address)) * NUISANCE_GAS_PER_CONTRACT_BYTE) + MIN_NUISANCE_GAS_PER_CONTRACT
);
}
}
/**
* Validation whenever a slot needs to be loaded. Checks that the account exists, charges
* nuisance gas if the slot hasn't been loaded before.
* @param _contract Address of the account to load from.
* @param _key 32 byte key to load.
*/
function _checkContractStorageLoad(
address _contract,
bytes32 _key
)
internal
{
// Another case of hidden complexity. If we didn't enforce this requirement, then a
// contract could pass in just enough gas to cause the INVALID_STATE_ACCESS check to fail
// on L1 but not on L2. A contract could use this behavior to prevent the
// OVM_ExecutionManager from detecting an invalid state access. Reverting with OUT_OF_GAS
// allows us to also charge for the full message nuisance gas, because you deserve that for
// trying to break the contract in this way.
if (gasleft() < MIN_GAS_FOR_INVALID_STATE_ACCESS) {
_revertWithFlag(RevertFlag.OUT_OF_GAS);
}
// We need to make sure that the transaction isn't trying to access storage that hasn't
// been provided to the OVM_StateManager. We'll immediately abort if this is the case.
// We know that we have enough gas to do this check because of the above test.
if (ovmStateManager.hasContractStorage(_contract, _key) == false) {
_revertWithFlag(RevertFlag.INVALID_STATE_ACCESS);
}
// Check whether the slot has been loaded before and mark it as loaded if not. We need
// this because "nuisance gas" only applies to the first time that a slot is loaded.
(
bool _wasContractStorageAlreadyLoaded
) = ovmStateManager.testAndSetContractStorageLoaded(_contract, _key);
// If we hadn't already loaded the account, then we'll need to charge some fixed amount of
// "nuisance gas".
if (_wasContractStorageAlreadyLoaded == false) {
_useNuisanceGas(NUISANCE_GAS_SLOAD);
}
}
/**
* Validation whenever a slot needs to be changed. Checks that the account exists, charges
* nuisance gas if the slot hasn't been changed before.
* @param _contract Address of the account to change.
* @param _key 32 byte key to change.
*/
function _checkContractStorageChange(
address _contract,
bytes32 _key
)
internal
{
// See `_checkContractStorageLoad` for more information.
if (gasleft() < MIN_GAS_FOR_INVALID_STATE_ACCESS) {
_revertWithFlag(RevertFlag.OUT_OF_GAS);
}
// See `_checkContractStorageLoad` for more information.
if (ovmStateManager.hasContractStorage(_contract, _key) == false) {
_revertWithFlag(RevertFlag.INVALID_STATE_ACCESS);
}
// Check whether the slot has been changed before and mark it as changed if not. We need
// this because "nuisance gas" only applies to the first time that a slot is changed.
(
bool _wasContractStorageAlreadyChanged
) = ovmStateManager.testAndSetContractStorageChanged(_contract, _key);
// If we hadn't already changed the account, then we'll need to charge some fixed amount of
// "nuisance gas".
if (_wasContractStorageAlreadyChanged == false) {
ovmStateManager.incrementTotalUncommittedContractStorage();
_useNuisanceGas(NUISANCE_GAS_SSTORE);
}
}
/************************************
* Internal Functions: Revert Logic *
************************************/
/**
* Simple encoding for revert data.
* @param _flag Flag to revert with.
* @param _data Additional user-provided revert data.
* @return _revertdata Encoded revert data.
*/
function _encodeRevertData(
RevertFlag _flag,
bytes memory _data
)
internal
returns (
bytes memory _revertdata
)
{
// Out of gas and create exceptions will fundamentally return no data, so simulating it shouldn't either.
if (
_flag == RevertFlag.OUT_OF_GAS
|| _flag == RevertFlag.CREATE_EXCEPTION
) {
return bytes('');
}
// INVALID_STATE_ACCESS doesn't need to return any data other than the flag.
if (_flag == RevertFlag.INVALID_STATE_ACCESS) {
return abi.encode(
_flag,
0,
0,
bytes('')
);
}
// Just ABI encode the rest of the parameters.
return abi.encode(
_flag,
messageRecord.nuisanceGasLeft,
transactionRecord.ovmGasRefund,
_data
);
}
/**
* Simple decoding for revert data.
* @param _revertdata Revert data to decode.
* @return _flag Flag used to revert.
* @return _nuisanceGasLeft Amount of nuisance gas unused by the message.
* @return _ovmGasRefund Amount of gas refunded during the message.
* @return _data Additional user-provided revert data.
*/
function _decodeRevertData(
bytes memory _revertdata
)
internal
returns (
RevertFlag _flag,
uint256 _nuisanceGasLeft,
uint256 _ovmGasRefund,
bytes memory _data
)
{
// A length of zero means the call ran out of gas, just return empty data.
if (_revertdata.length == 0) {
return (
RevertFlag.OUT_OF_GAS,
0,
0,
bytes('')
);
}
// ABI decode the incoming data.
return abi.decode(_revertdata, (RevertFlag, uint256, uint256, bytes));
}
/**
* Causes a message to revert or abort.
* @param _flag Flag to revert with.
* @param _data Additional user-provided data.
*/
function _revertWithFlag(
RevertFlag _flag,
bytes memory _data
)
internal
{
// We don't want to revert when we're inside a CREATE or CREATE2, because those opcodes
// fail silently (we can't pass any data upwards). Instead, we set a flag and return a
// *single* byte, something the OVM_ExecutionManager will not return in any other case.
// We're thereby allowed to communicate failure without allowing contracts to trick us into
// thinking there was a failure.
if (messageContext.isCreation) {
messageRecord.revertFlag = _flag;
assembly {
return(0, 1)
}
}
// If we're not inside a CREATE or CREATE2, we can simply encode the necessary data and
// revert normally.
bytes memory revertdata = _encodeRevertData(
_flag,
_data
);
assembly {
revert(add(revertdata, 0x20), mload(revertdata))
}
}
/**
* Causes a message to revert or abort.
* @param _flag Flag to revert with.
*/
function _revertWithFlag(
RevertFlag _flag
)
internal
{
_revertWithFlag(_flag, bytes(''));
}
/******************************************
* Internal Functions: Nuisance Gas Logic *
******************************************/
/**
* Computes the nuisance gas limit from the gas limit.
* @dev This function is currently using a naive implementation whereby the nuisance gas limit
* is set to exactly equal the lesser of the gas limit or remaining gas. It's likely that
* this implementation is perfectly fine, but we may change this formula later.
* @param _gasLimit Gas limit to compute from.
* @return _nuisanceGasLimit Computed nuisance gas limit.
*/
function _getNuisanceGasLimit(
uint256 _gasLimit
)
internal
view
returns (
uint256 _nuisanceGasLimit
)
{
return _gasLimit < gasleft() ? _gasLimit : gasleft();
}
/**
* Uses a certain amount of nuisance gas.
* @param _amount Amount of nuisance gas to use.
*/
function _useNuisanceGas(
uint256 _amount
)
internal
{
// Essentially the same as a standard OUT_OF_GAS, except we also retain a record of the gas
// refund to be given at the end of the transaction.
if (messageRecord.nuisanceGasLeft < _amount) {
_revertWithFlag(RevertFlag.EXCEEDS_NUISANCE_GAS);
}
messageRecord.nuisanceGasLeft -= _amount;
}
/************************************
* Internal Functions: Gas Metering *
************************************/
/**
* Checks whether a transaction needs to start a new epoch and does so if necessary.
* @param _timestamp Transaction timestamp.
*/
function _checkNeedsNewEpoch(
uint256 _timestamp
)
internal
{
if (
_timestamp >= (
_getGasMetadata(GasMetadataKey.CURRENT_EPOCH_START_TIMESTAMP)
+ gasMeterConfig.secondsPerEpoch
)
) {
_putGasMetadata(
GasMetadataKey.CURRENT_EPOCH_START_TIMESTAMP,
_timestamp
);
_putGasMetadata(
GasMetadataKey.PREV_EPOCH_SEQUENCER_QUEUE_GAS,
_getGasMetadata(
GasMetadataKey.CUMULATIVE_SEQUENCER_QUEUE_GAS
)
);
_putGasMetadata(
GasMetadataKey.PREV_EPOCH_L1TOL2_QUEUE_GAS,
_getGasMetadata(
GasMetadataKey.CUMULATIVE_L1TOL2_QUEUE_GAS
)
);
}
}
/**
* Validates the gas limit for a given transaction.
* @param _gasLimit Gas limit provided by the transaction.
* @param _queueOrigin Queue from which the transaction orginated.
* @return _valid Whether or not the gas limit is valid.
*/
function _isValidGasLimit(
uint256 _gasLimit,
Lib_OVMCodec.QueueOrigin _queueOrigin
)
internal
returns (
bool _valid
)
{
if (_gasLimit > gasMeterConfig.maxTransactionGasLimit) {
return false;
}
if (_gasLimit < gasMeterConfig.minTransactionGasLimit) {
return false;
}
GasMetadataKey cumulativeGasKey;
GasMetadataKey prevEpochGasKey;
if (_queueOrigin == Lib_OVMCodec.QueueOrigin.SEQUENCER_QUEUE) {
cumulativeGasKey = GasMetadataKey.CUMULATIVE_SEQUENCER_QUEUE_GAS;
prevEpochGasKey = GasMetadataKey.PREV_EPOCH_SEQUENCER_QUEUE_GAS;
} else {
cumulativeGasKey = GasMetadataKey.CUMULATIVE_L1TOL2_QUEUE_GAS;
prevEpochGasKey = GasMetadataKey.PREV_EPOCH_L1TOL2_QUEUE_GAS;
}
return (
(
_getGasMetadata(cumulativeGasKey)
- _getGasMetadata(prevEpochGasKey)
+ _gasLimit
) > gasMeterConfig.maxGasPerQueuePerEpoch
);
}
/**
* Updates the cumulative gas after a transaction.
* @param _gasUsed Gas used by the transaction.
* @param _queueOrigin Queue from which the transaction orginated.
*/
function _updateCumulativeGas(
uint256 _gasUsed,
Lib_OVMCodec.QueueOrigin _queueOrigin
)
internal
{
GasMetadataKey cumulativeGasKey;
if (_queueOrigin == Lib_OVMCodec.QueueOrigin.SEQUENCER_QUEUE) {
cumulativeGasKey = GasMetadataKey.CUMULATIVE_SEQUENCER_QUEUE_GAS;
} else {
cumulativeGasKey = GasMetadataKey.CUMULATIVE_L1TOL2_QUEUE_GAS;
}
_putGasMetadata(
cumulativeGasKey,
(
_getGasMetadata(cumulativeGasKey)
+ gasMeterConfig.minTransactionGasLimit
+ _gasUsed
- transactionRecord.ovmGasRefund
)
);
}
/**
* Retrieves the value of a gas metadata key.
* @param _key Gas metadata key to retrieve.
* @return _value Value stored at the given key.
*/
function _getGasMetadata(
GasMetadataKey _key
)
internal
returns (
uint256 _value
)
{
return uint256(_getContractStorage(
GAS_METADATA_ADDRESS,
bytes32(uint256(_key))
));
}
/**
* Sets the value of a gas metadata key.
* @param _key Gas metadata key to set.
* @param _value Value to store at the given key.
*/
function _putGasMetadata(
GasMetadataKey _key,
uint256 _value
)
internal
{
_putContractStorage(
GAS_METADATA_ADDRESS,
bytes32(uint256(_key)),
bytes32(uint256(_value))
);
}
/*****************************************
* Internal Functions: Execution Context *
*****************************************/
/**
* Swaps over to a new message context.
* @param _prevMessageContext Context we're switching from.
* @param _nextMessageContext Context we're switching to.
*/
function _switchMessageContext(
MessageContext memory _prevMessageContext,
MessageContext memory _nextMessageContext
)
internal
{
// Avoid unnecessary the SSTORE.
if (_prevMessageContext.ovmCALLER != _nextMessageContext.ovmCALLER) {
messageContext.ovmCALLER = _nextMessageContext.ovmCALLER;
}
// Avoid unnecessary the SSTORE.
if (_prevMessageContext.ovmADDRESS != _nextMessageContext.ovmADDRESS) {
messageContext.ovmADDRESS = _nextMessageContext.ovmADDRESS;
}
// Avoid unnecessary the SSTORE.
if (_prevMessageContext.isStatic != _nextMessageContext.isStatic) {
messageContext.isStatic = _nextMessageContext.isStatic;
}
// Avoid unnecessary the SSTORE.
if (_prevMessageContext.isCreation != _nextMessageContext.isCreation) {
messageContext.isCreation = _nextMessageContext.isCreation;
}
}
/**
* Initializes the execution context.
* @param _transaction OVM transaction being executed.
*/
function _initContext(
Lib_OVMCodec.Transaction memory _transaction
)
internal
{
transactionContext.ovmTIMESTAMP = _transaction.timestamp;
transactionContext.ovmNUMBER = _transaction.number;
transactionContext.ovmTXGASLIMIT = _transaction.gasLimit;
transactionContext.ovmL1QUEUEORIGIN = _transaction.l1QueueOrigin;
transactionContext.ovmL1TXORIGIN = _transaction.l1Txorigin;
transactionContext.ovmGASLIMIT = gasMeterConfig.maxGasPerQueuePerEpoch;
}
/**
* Resets the transaction and message context.
*/
function _resetContext()
internal
{
transactionContext.ovmL1TXORIGIN = address(0);
transactionContext.ovmTIMESTAMP = 0;
transactionContext.ovmNUMBER = 0;
transactionContext.ovmGASLIMIT = 0;
transactionContext.ovmTXGASLIMIT = 0;
transactionContext.ovmL1QUEUEORIGIN = Lib_OVMCodec.QueueOrigin.SEQUENCER_QUEUE;
transactionRecord.ovmGasRefund = 0;
messageContext.ovmCALLER = address(0);
messageContext.ovmADDRESS = address(0);
messageContext.isStatic = false;
messageRecord.nuisanceGasLeft = 0;
messageRecord.revertFlag = RevertFlag.DID_NOT_REVERT;
}
}
packages/contracts/build/contracts/OVM/execution/OVM_SafetyChecker.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Interface Imports */
import { iOVM_SafetyChecker } from "../../iOVM/execution/iOVM_SafetyChecker.sol";
/**
* @title OVM_SafetyChecker
*/
contract OVM_SafetyChecker is iOVM_SafetyChecker {
/********************
* Public Functions *
********************/
/**
* Checks that a given bytecode string is considered safe.
* @param _bytecode Bytecode string to check.
* @return _safe Whether or not the bytecode is safe.
*/
function isBytecodeSafe(
bytes memory _bytecode
)
override
public
view
returns (
bool _safe
)
{
return true;
}
}
packages/contracts/build/contracts/OVM/execution/OVM_StateManager.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/* Interface Imports */
import { iOVM_StateManager } from "../../iOVM/execution/iOVM_StateManager.sol";
/**
* @title OVM_StateManager
*/
contract OVM_StateManager is iOVM_StateManager {
/**********************
* Contract Constants *
**********************/
bytes32 constant internal EMPTY_ACCOUNT_CODE_HASH = 0x00004B1DC0DE000000004B1DC0DE000000004B1DC0DE000000004B1DC0DE0000;
bytes32 constant internal STORAGE_XOR_VALUE = 0xFEEDFACECAFEBEEFFEEDFACECAFEBEEFFEEDFACECAFEBEEFFEEDFACECAFEBEEF;
/*******************************************
* Contract Variables: Contract References *
*******************************************/
address internal owner;
address internal ovmExecutionManager;
/****************************************
* Contract Variables: Internal Storage *
****************************************/
mapping (address => Lib_OVMCodec.Account) internal accounts;
mapping (address => mapping (bytes32 => bytes32)) internal contractStorage;
mapping (address => mapping (bytes32 => bool)) internal verifiedContractStorage;
mapping (bytes32 => ItemState) internal itemStates;
uint256 internal totalUncommittedAccounts;
uint256 internal totalUncommittedContractStorage;
/***************
* Constructor *
***************/
/**
* @param _owner Address of the owner of this contract.
*/
constructor(
address _owner
) {
owner = _owner;
}
/**********************
* Function Modifiers *
**********************/
/**
* Simple authentication, this contract should only be accessible to the owner or to the
* OVM_ExecutionManager during the transaction execution process.
*/
modifier authenticated() {
require(
msg.sender == owner || msg.sender == ovmExecutionManager,
"Function can only be called by authenticated addresses"
);
_;
}
/***************************
* Public Functions: Setup *
***************************/
/**
* Sets the address of the OVM_ExecutionManager.
* @param _ovmExecutionManager Address of the OVM_ExecutionManager.
*/
function setExecutionManager(
address _ovmExecutionManager
)
override
public
authenticated
{
ovmExecutionManager = _ovmExecutionManager;
}
/************************************
* Public Functions: Account Access *
************************************/
/**
* Inserts an account into the state.
* @param _address Address of the account to insert.
* @param _account Account to insert for the given address.
*/
function putAccount(
address _address,
Lib_OVMCodec.Account memory _account
)
override
public
authenticated
{
accounts[_address] = _account;
}
/**
* Retrieves an account from the state.
* @param _address Address of the account to retrieve.
* @return _account Account for the given address.
*/
function getAccount(address _address)
override
public
view
returns (
Lib_OVMCodec.Account memory _account
)
{
return accounts[_address];
}
/**
* Checks whether the state has a given account.
* @param _address Address of the account to check.
* @return _exists Whether or not the state has the account.
*/
function hasAccount(
address _address
)
override
public
view
returns (
bool _exists
)
{
return accounts[_address].codeHash != bytes32(0);
}
/**
* Checks whether the state has a given known empty account.
* @param _address Address of the account to check.
* @return _exists Whether or not the state has the empty account.
*/
function hasEmptyAccount(
address _address
)
override
public
view
returns (
bool _exists
)
{
return accounts[_address].codeHash == EMPTY_ACCOUNT_CODE_HASH;
}
/**
* Sets the nonce of an account.
* @param _address Address of the account to modify.
* @param _nonce New account nonce.
*/
function setAccountNonce(
address _address,
uint256 _nonce
)
override
public
authenticated
{
accounts[_address].nonce = _nonce;
}
/**
* Gets the nonce of an account.
* @param _address Address of the account to access.
* @return _nonce Nonce of the account.
*/
function getAccountNonce(
address _address
)
override
public
view
returns (
uint256 _nonce
)
{
return accounts[_address].nonce;
}
/**
* Retrieves the Ethereum address of an account.
* @param _address Address of the account to access.
* @return _ethAddress Corresponding Ethereum address.
*/
function getAccountEthAddress(
address _address
)
override
public
view
returns (
address _ethAddress
)
{
return accounts[_address].ethAddress;
}
/**
* Initializes a pending account (during CREATE or CREATE2) with the default values.
* @param _address Address of the account to initialize.
*/
function initPendingAccount(
address _address
)
override
public
authenticated
{
Lib_OVMCodec.Account storage account = accounts[_address];
account.nonce = 1;
account.codeHash = keccak256(hex'80');
account.isFresh = true;
}
/**
* Finalizes the creation of a pending account (during CREATE or CREATE2).
* @param _address Address of the account to finalize.
* @param _ethAddress Address of the account's associated contract on Ethereum.
* @param _codeHash Hash of the account's code.
*/
function commitPendingAccount(
address _address,
address _ethAddress,
bytes32 _codeHash
)
override
public
authenticated
{
Lib_OVMCodec.Account storage account = accounts[_address];
account.ethAddress = _ethAddress;
account.codeHash = _codeHash;
}
/**
* Checks whether an account has already been retrieved, and marks it as retrieved if not.
* @param _address Address of the account to check.
* @return _wasAccountAlreadyLoaded Whether or not the account was already loaded.
*/
function testAndSetAccountLoaded(
address _address
)
override
public
authenticated
returns (
bool _wasAccountAlreadyLoaded
)
{
return _testAndSetItemState(
keccak256(abi.encodePacked(_address)),
ItemState.ITEM_LOADED
);
}
/**
* Checks whether an account has already been modified, and marks it as modified if not.
* @param _address Address of the account to check.
* @return _wasAccountAlreadyChanged Whether or not the account was already modified.
*/
function testAndSetAccountChanged(
address _address
)
override
public
authenticated
returns (
bool _wasAccountAlreadyChanged
)
{
return _testAndSetItemState(
keccak256(abi.encodePacked(_address)),
ItemState.ITEM_CHANGED
);
}
/**
* Attempts to mark an account as committed.
* @param _address Address of the account to commit.
* @return _wasAccountCommitted Whether or not the account was committed.
*/
function commitAccount(
address _address
)
override
public
authenticated
returns (
bool _wasAccountCommitted
)
{
bytes32 item = keccak256(abi.encodePacked(_address));
if (itemStates[item] != ItemState.ITEM_CHANGED) {
return false;
}
itemStates[item] = ItemState.ITEM_COMMITTED;
totalUncommittedAccounts -= 1;
return true;
}
/**
* Increments the total number of uncommitted accounts.
*/
function incrementTotalUncommittedAccounts()
override
public
authenticated
{
totalUncommittedAccounts += 1;
}
/**
* Gets the total number of uncommitted accounts.
* @return _total Total uncommitted accounts.
*/
function getTotalUncommittedAccounts()
override
public
view
returns (
uint256 _total
)
{
return totalUncommittedAccounts;
}
/************************************
* Public Functions: Storage Access *
************************************/
/**
* Changes a contract storage slot value.
* @param _contract Address of the contract to modify.
* @param _key 32 byte storage slot key.
* @param _value 32 byte storage slot value.
*/
function putContractStorage(
address _contract,
bytes32 _key,
bytes32 _value
)
override
public
authenticated
{
// A hilarious optimization. `SSTORE`ing a value of `bytes32(0)` is common enough that it's
// worth populating this with a non-zero value in advance (during the fraud proof
// initialization phase) to cut the execution-time cost down to 5000 gas.
contractStorage[_contract][_key] = _value ^ STORAGE_XOR_VALUE;
// Only used when initially populating the contract storage. OVM_ExecutionManager will
// perform a `hasContractStorage` INVALID_STATE_ACCESS check before putting any contract
// storage because writing to zero when the actual value is nonzero causes a gas
// discrepancy. Could be moved into a new `putVerifiedContractStorage` function, or
// something along those lines.
if (verifiedContractStorage[_contract][_key] == false) {
verifiedContractStorage[_contract][_key] = true;
}
}
/**
* Retrieves a contract storage slot value.
* @param _contract Address of the contract to access.
* @param _key 32 byte storage slot key.
* @return _value 32 byte storage slot value.
*/
function getContractStorage(
address _contract,
bytes32 _key
)
override
public
view
returns (
bytes32 _value
)
{
// Storage XOR system doesn't work for newly created contracts that haven't set this
// storage slot value yet.
if (
verifiedContractStorage[_contract][_key] == false
&& accounts[_contract].isFresh
) {
return bytes32(0);
}
// See `putContractStorage` for more information about the XOR here.
return contractStorage[_contract][_key] ^ STORAGE_XOR_VALUE;
}
/**
* Checks whether a contract storage slot exists in the state.
* @param _contract Address of the contract to access.
* @param _key 32 byte storage slot key.
* @return _exists Whether or not the key was set in the state.
*/
function hasContractStorage(
address _contract,
bytes32 _key
)
override
public
view
returns (
bool _exists
)
{
return verifiedContractStorage[_contract][_key] || accounts[_contract].isFresh;
}
/**
* Checks whether a storage slot has already been retrieved, and marks it as retrieved if not.
* @param _contract Address of the contract to check.
* @param _key 32 byte storage slot key.
* @return _wasContractStorageAlreadyLoaded Whether or not the slot was already loaded.
*/
function testAndSetContractStorageLoaded(
address _contract,
bytes32 _key
)
override
public
authenticated
returns (
bool _wasContractStorageAlreadyLoaded
)
{
return _testAndSetItemState(
keccak256(abi.encodePacked(_contract, _key)),
ItemState.ITEM_LOADED
);
}
/**
* Checks whether a storage slot has already been modified, and marks it as modified if not.
* @param _contract Address of the contract to check.
* @param _key 32 byte storage slot key.
* @return _wasContractStorageAlreadyChanged Whether or not the slot was already modified.
*/
function testAndSetContractStorageChanged(
address _contract,
bytes32 _key
)
override
public
authenticated
returns (
bool _wasContractStorageAlreadyChanged
)
{
return _testAndSetItemState(
keccak256(abi.encodePacked(_contract, _key)),
ItemState.ITEM_CHANGED
);
}
/**
* Attempts to mark a storage slot as committed.
* @param _contract Address of the account to commit.
* @param _key 32 byte slot key to commit.
* @return _wasContractStorageCommitted Whether or not the slot was committed.
*/
function commitContractStorage(
address _contract,
bytes32 _key
)
override
public
authenticated
returns (
bool _wasContractStorageCommitted
)
{
bytes32 item = keccak256(abi.encodePacked(_contract, _key));
if (itemStates[item] != ItemState.ITEM_CHANGED) {
return false;
}
itemStates[item] = ItemState.ITEM_COMMITTED;
totalUncommittedContractStorage -= 1;
return true;
}
/**
* Increments the total number of uncommitted storage slots.
*/
function incrementTotalUncommittedContractStorage()
override
public
authenticated
{
totalUncommittedContractStorage += 1;
}
/**
* Gets the total number of uncommitted storage slots.
* @return _total Total uncommitted storage slots.
*/
function getTotalUncommittedContractStorage()
override
public
view
returns (
uint256 _total
)
{
return totalUncommittedContractStorage;
}
/**********************
* Internal Functions *
**********************/
/**
* Checks whether an item is in a particular state (ITEM_LOADED or ITEM_CHANGED) and sets the
* item to the provided state if not.
* @param _item 32 byte item ID to check.
* @param _minItemState Minumum state that must be satisfied by the item.
* @return _wasItemState Whether or not the item was already in the state.
*/
function _testAndSetItemState(
bytes32 _item,
ItemState _minItemState
)
internal
returns (
bool _wasItemState
)
{
bool wasItemState = itemStates[_item] >= _minItemState;
if (wasItemState == false) {
itemStates[_item] = _minItemState;
}
return wasItemState;
}
}
packages/contracts/build/contracts/OVM/execution/OVM_StateManagerFactory.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Interface Imports */
import { iOVM_StateManager } from "../../iOVM/execution/iOVM_StateManager.sol";
import { iOVM_StateManagerFactory } from "../../iOVM/execution/iOVM_StateManagerFactory.sol";
/* Contract Imports */
import { OVM_StateManager } from "./OVM_StateManager.sol";
/**
* @title OVM_StateManagerFactory
*/
contract OVM_StateManagerFactory is iOVM_StateManagerFactory {
/***************************************
* Public Functions: Contract Creation *
***************************************/
/**
* Creates a new OVM_StateManager
* @param _owner Owner of the created contract.
* @return _ovmStateManager New OVM_StateManager instance.
*/
function create(
address _owner
)
override
public
returns (
iOVM_StateManager _ovmStateManager
)
{
return new OVM_StateManager(_owner);
}
}
packages/contracts/build/contracts/OVM/precompiles/OVM_DeployerWhitelist.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Library Imports */
import { Lib_Bytes32Utils } from "../../libraries/utils/Lib_Bytes32Utils.sol";
/* Interface Imports */
import { iOVM_DeployerWhitelist } from "../../iOVM/precompiles/iOVM_DeployerWhitelist.sol";
import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
/**
* @title OVM_DeployerWhitelist
*/
contract OVM_DeployerWhitelist is iOVM_DeployerWhitelist {
/**********************
* Contract Constants *
**********************/
bytes32 internal constant KEY_INITIALIZED = 0x0000000000000000000000000000000000000000000000000000000000000010;
bytes32 internal constant KEY_OWNER = 0x0000000000000000000000000000000000000000000000000000000000000011;
bytes32 internal constant KEY_ALLOW_ARBITRARY_DEPLOYMENT = 0x0000000000000000000000000000000000000000000000000000000000000012;
/**********************
* Function Modifiers *
**********************/
/**
* Blocks functions to anyone except the contract owner.
*/
modifier onlyOwner() {
iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
address owner = Lib_Bytes32Utils.toAddress(
ovmExecutionManager.ovmSLOAD(
KEY_OWNER
)
);
require(
ovmExecutionManager.ovmCALLER() == owner,
"Function can only be called by the owner of this contract."
);
_;
}
/********************
* Public Functions *
********************/
/**
* Initializes the whitelist.
* @param _owner Address of the owner for this contract.
* @param _allowArbitraryDeployment Whether or not to allow arbitrary contract deployment.
*/
function initialize(
address _owner,
bool _allowArbitraryDeployment
)
override
public
{
iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
bool initialized = Lib_Bytes32Utils.toBool(
ovmExecutionManager.ovmSLOAD(KEY_INITIALIZED)
);
if (initialized == true) {
return;
}
ovmExecutionManager.ovmSSTORE(
KEY_INITIALIZED,
Lib_Bytes32Utils.fromBool(true)
);
ovmExecutionManager.ovmSSTORE(
KEY_OWNER,
Lib_Bytes32Utils.fromAddress(_owner)
);
ovmExecutionManager.ovmSSTORE(
KEY_ALLOW_ARBITRARY_DEPLOYMENT,
Lib_Bytes32Utils.fromBool(_allowArbitraryDeployment)
);
}
/**
* Adds or removes an address from the deployment whitelist.
* @param _deployer Address to update permissions for.
* @param _isWhitelisted Whether or not the address is whitelisted.
*/
function setWhitelistedDeployer(
address _deployer,
bool _isWhitelisted
)
override
public
onlyOwner
{
iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
ovmExecutionManager.ovmSSTORE(
Lib_Bytes32Utils.fromAddress(_deployer),
Lib_Bytes32Utils.fromBool(_isWhitelisted)
);
}
/**
* Updates the owner of this contract.
* @param _owner Address of the new owner.
*/
function setOwner(
address _owner
)
override
public
onlyOwner
{
iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
ovmExecutionManager.ovmSSTORE(
KEY_OWNER,
Lib_Bytes32Utils.fromAddress(_owner)
);
}
/**
* Updates the arbitrary deployment flag.
* @param _allowArbitraryDeployment Whether or not to allow arbitrary contract deployment.
*/
function setAllowArbitraryDeployment(
bool _allowArbitraryDeployment
)
override
public
onlyOwner
{
iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
ovmExecutionManager.ovmSSTORE(
KEY_ALLOW_ARBITRARY_DEPLOYMENT,
Lib_Bytes32Utils.fromBool(_allowArbitraryDeployment)
);
}
/**
* Permanently enables arbitrary contract deployment and deletes the owner.
*/
function enableArbitraryContractDeployment()
override
public
onlyOwner
{
setAllowArbitraryDeployment(true);
setOwner(address(0));
}
/**
* Checks whether an address is allowed to deploy contracts.
* @param _deployer Address to check.
* @return _allowed Whether or not the address can deploy contracts.
*/
function isDeployerAllowed(
address _deployer
)
override
public
returns (
bool _allowed
)
{
iOVM_ExecutionManager ovmExecutionManager = iOVM_ExecutionManager(msg.sender);
bool initialized = Lib_Bytes32Utils.toBool(
ovmExecutionManager.ovmSLOAD(KEY_INITIALIZED)
);
if (initialized == false) {
return true;
}
bool allowArbitraryDeployment = Lib_Bytes32Utils.toBool(
ovmExecutionManager.ovmSLOAD(KEY_ALLOW_ARBITRARY_DEPLOYMENT)
);
if (allowArbitraryDeployment == true) {
return true;
}
bool isWhitelisted = Lib_Bytes32Utils.toBool(
ovmExecutionManager.ovmSLOAD(
Lib_Bytes32Utils.fromAddress(_deployer)
)
);
return isWhitelisted;
}
}
packages/contracts/build/contracts/OVM/precompiles/OVM_L1MessageSender.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Interface Imports */
import { iOVM_L1MessageSender } from "../../iOVM/precompiles/iOVM_L1MessageSender.sol";
import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
/**
* @title OVM_L1MessageSender
*/
contract OVM_L1MessageSender is iOVM_L1MessageSender {
/********************
* Public Functions *
********************/
/**
* @return _l1MessageSender L1 message sender address (msg.sender).
*/
function getL1MessageSender()
override
public
returns (
address _l1MessageSender
)
{
return iOVM_ExecutionManager(msg.sender).ovmL1TXORIGIN();
}
}
packages/contracts/build/contracts/OVM/precompiles/OVM_L2ToL1MessagePasser.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Interface Imports */
import { iOVM_L2ToL1MessagePasser } from "../../iOVM/precompiles/iOVM_L2ToL1MessagePasser.sol";
import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
/**
* @title OVM_L2ToL1MessagePasser
*/
contract OVM_L2ToL1MessagePasser is iOVM_L2ToL1MessagePasser {
/**********************
* Contract Variables *
**********************/
uint256 internal nonce;
/********************
* Public Functions *
********************/
/**
* Passes a message to L1.
* @param _message Message to pass to L1.
*/
function passMessageToL1(
bytes memory _message
)
override
public
{
// For now, to be trustfully relayed by sequencer to L1, so just emit
// an event for the sequencer to pick up.
emit L2ToL1Message(
nonce,
iOVM_ExecutionManager(msg.sender).ovmCALLER(),
_message
);
nonce = nonce + 1;
}
}
packages/contracts/build/contracts/OVM/queue/OVM_BaseQueue.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/* Interface Imports */
import { iOVM_BaseQueue } from "../../iOVM/queue/iOVM_BaseQueue.sol";
/**
* @title OVM_BaseQueue
*/
contract OVM_BaseQueue is iOVM_BaseQueue {
/****************************************
* Contract Variables: Internal Storage *
****************************************/
Lib_OVMCodec.QueueElement[] internal queue;
uint256 internal front;
/**********************
* Function Modifiers *
**********************/
/**
* Asserts that the queue is not empty.
*/
modifier notEmpty() {
require(
size() > 0,
"Queue is empty."
);
_;
}
/**********************************
* Public Functions: Queue Access *
**********************************/
/**
* Gets the size of the queue.
* @return _size Number of elements in the queue.
*/
function size()
override
public
view
returns (
uint256 _size
)
{
return front >= queue.length ? 0 : queue.length - front;
}
/**
* Gets the top element of the queue.
* @return _element First element in the queue.
*/
function peek()
override
public
view
notEmpty
returns (
Lib_OVMCodec.QueueElement memory _element
)
{
return queue[front];
}
/******************************************
* Internal Functions: Queue Manipulation *
******************************************/
/**
* Adds an element to the queue.
* @param _element Queue element to add to the queue.
*/
function _enqueue(
Lib_OVMCodec.QueueElement memory _element
)
internal
{
queue.push(_element);
}
/**
* Pops an element from the queue.
* @return _element Queue element popped from the queue.
*/
function _dequeue()
internal
notEmpty
returns (
Lib_OVMCodec.QueueElement memory _element
)
{
_element = queue[front];
delete queue[front];
front += 1;
return _element;
}
}
packages/contracts/build/contracts/OVM/queue/OVM_L1ToL2TransactionQueue.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
/* Interface Imports */
import { iOVM_L1ToL2TransactionQueue } from "../../iOVM/queue/iOVM_L1ToL2TransactionQueue.sol";
/* Contract Imports */
import { OVM_BaseQueue } from "./OVM_BaseQueue.sol";
/**
* @title OVM_L1ToL2TransactionQueue
*/
contract OVM_L1ToL2TransactionQueue is iOVM_L1ToL2TransactionQueue, OVM_BaseQueue, Lib_AddressResolver {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
address internal ovmCanonicalTransactionChain;
/***************
* Constructor *
***************/
/**
* @param _libAddressManager Address of the Address Manager.
*/
constructor(
address _libAddressManager
)
Lib_AddressResolver(_libAddressManager)
{
ovmCanonicalTransactionChain = resolve("OVM_CanonicalTransactionChain");
}
/****************************************
* Public Functions: Queue Manipulation *
****************************************/
/**
* Adds a transaction to the queue.
* @param _target Target contract to send the transaction to.
* @param _gasLimit Gas limit for the given transaction.
* @param _data Transaction data.
*/
function enqueue(
address _target,
uint256 _gasLimit,
bytes memory _data
)
override
public
{
Lib_OVMCodec.QueueElement memory element = Lib_OVMCodec.QueueElement({
timestamp: block.timestamp,
batchRoot: keccak256(abi.encodePacked(
_target,
_gasLimit,
_data
)),
isL1ToL2Batch: true
});
_enqueue(element);
}
/**
* Pops an element from the queue.
*/
function dequeue()
override
public
{
require(
msg.sender == ovmCanonicalTransactionChain,
"Sender is not allowed to enqueue."
);
_dequeue();
}
}
packages/contracts/build/contracts/OVM/verification/OVM_FraudVerifier.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
/* Interface Imports */
import { iOVM_FraudVerifier } from "../../iOVM/verification/iOVM_FraudVerifier.sol";
import { iOVM_StateTransitioner } from "../../iOVM/verification/iOVM_StateTransitioner.sol";
import { iOVM_StateTransitionerFactory } from "../../iOVM/verification/iOVM_StateTransitionerFactory.sol";
import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
import { iOVM_StateManagerFactory } from "../../iOVM/execution/iOVM_StateManagerFactory.sol";
import { iOVM_StateCommitmentChain } from "../../iOVM/chain/iOVM_StateCommitmentChain.sol";
import { iOVM_CanonicalTransactionChain } from "../../iOVM/chain/iOVM_CanonicalTransactionChain.sol";
contract OVM_FraudVerifier is iOVM_FraudVerifier, Lib_AddressResolver {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
iOVM_StateCommitmentChain internal ovmStateCommitmentChain;
iOVM_CanonicalTransactionChain internal ovmCanonicalTransactionChain;
/*******************************************
* Contract Variables: Internal Accounting *
*******************************************/
mapping (bytes32 => iOVM_StateTransitioner) internal transitioners;
/***************
* Constructor *
***************/
/**
* @param _libAddressManager Address of the Address Manager.
*/
constructor(
address _libAddressManager
)
Lib_AddressResolver(_libAddressManager)
{
ovmStateCommitmentChain = iOVM_StateCommitmentChain(resolve("OVM_StateCommitmentChain"));
ovmCanonicalTransactionChain = iOVM_CanonicalTransactionChain(resolve("OVM_CanonicalTransactionChain"));
}
/***************************************
* Public Functions: Transition Status *
***************************************/
/**
* Retrieves the state transitioner for a given root.
* @param _preStateRoot State root to query a transitioner for.
* @return _transitioner Corresponding state transitioner contract.
*/
function getStateTransitioner(
bytes32 _preStateRoot
)
override
public
view
returns (
iOVM_StateTransitioner _transitioner
)
{
return transitioners[_preStateRoot];
}
/****************************************
* Public Functions: Fraud Verification *
****************************************/
/**
* Begins the fraud verification process.
* @param _preStateRoot State root before the fraudulent transaction.
* @param _preStateRootBatchHeader Batch header for the provided pre-state root.
* @param _preStateRootProof Inclusion proof for the provided pre-state root.
* @param _transaction OVM transaction claimed to be fraudulent.
* @param _transactionBatchHeader Batch header for the provided transaction.
* @param _transactionProof Inclusion proof for the provided transaction.
*/
function initializeFraudVerification(
bytes32 _preStateRoot,
Lib_OVMCodec.ChainBatchHeader memory _preStateRootBatchHeader,
Lib_OVMCodec.ChainInclusionProof memory _preStateRootProof,
Lib_OVMCodec.Transaction memory _transaction,
Lib_OVMCodec.ChainBatchHeader memory _transactionBatchHeader,
Lib_OVMCodec.ChainInclusionProof memory _transactionProof
)
override
public
{
if (_hasStateTransitioner(_preStateRoot)) {
return;
}
require(
_verifyStateRoot(
_preStateRoot,
_preStateRootBatchHeader,
_preStateRootProof
),
"Invalid pre-state root inclusion proof."
);
require(
_verifyTransaction(
_transaction,
_transactionBatchHeader,
_transactionProof
),
"Invalid transaction inclusion proof."
);
transitioners[_preStateRoot] = iOVM_StateTransitionerFactory(
resolve("OVM_StateTransitionerFactory")
).create(
address(libAddressManager),
_preStateRootProof.index,
_preStateRoot,
Lib_OVMCodec.hashTransaction(_transaction)
);
}
/**
* Finalizes the fraud verification process.
* @param _preStateRoot State root before the fraudulent transaction.
* @param _preStateRootBatchHeader Batch header for the provided pre-state root.
* @param _preStateRootProof Inclusion proof for the provided pre-state root.
* @param _postStateRoot State root after the fraudulent transaction.
* @param _postStateRootBatchHeader Batch header for the provided post-state root.
* @param _postStateRootProof Inclusion proof for the provided post-state root.
*/
function finalizeFraudVerification(
bytes32 _preStateRoot,
Lib_OVMCodec.ChainBatchHeader memory _preStateRootBatchHeader,
Lib_OVMCodec.ChainInclusionProof memory _preStateRootProof,
bytes32 _postStateRoot,
Lib_OVMCodec.ChainBatchHeader memory _postStateRootBatchHeader,
Lib_OVMCodec.ChainInclusionProof memory _postStateRootProof
)
override
public
{
iOVM_StateTransitioner transitioner = transitioners[_preStateRoot];
require(
transitioner.isComplete() == true,
"State transition process must be completed prior to finalization."
);
require(
_postStateRootProof.index == _preStateRootProof.index + 1,
"Invalid post-state root index."
);
require(
_verifyStateRoot(
_preStateRoot,
_preStateRootBatchHeader,
_preStateRootProof
),
"Invalid pre-state root inclusion proof."
);
require(
_verifyStateRoot(
_postStateRoot,
_postStateRootBatchHeader,
_postStateRootProof
),
"Invalid post-state root inclusion proof."
);
require(
_postStateRoot != transitioner.getPostStateRoot(),
"State transition has not been proven fraudulent."
);
ovmStateCommitmentChain.deleteStateBatch(
_postStateRootBatchHeader
);
}
/************************************
* Internal Functions: Verification *
************************************/
/**
* Checks whether a transitioner already exists for a given pre-state root.
* @param _preStateRoot Pre-state root to check.
* @return _exists Whether or not we already have a transitioner for the root.
*/
function _hasStateTransitioner(
bytes32 _preStateRoot
)
internal
view
returns (
bool _exists
)
{
return address(transitioners[_preStateRoot]) != address(0);
}
/**
* Verifies inclusion of a state root.
* @param _stateRoot State root to verify
* @param _stateRootBatchHeader Batch header for the provided state root.
* @param _stateRootProof Inclusion proof for the provided state root.
* @return _verified Whether or not the root was included.
*/
function _verifyStateRoot(
bytes32 _stateRoot,
Lib_OVMCodec.ChainBatchHeader memory _stateRootBatchHeader,
Lib_OVMCodec.ChainInclusionProof memory _stateRootProof
)
internal
view
returns (
bool _verified
)
{
return ovmStateCommitmentChain.verifyElement(
abi.encodePacked(_stateRoot),
_stateRootBatchHeader,
_stateRootProof
);
}
/**
* Verifies inclusion of a given transaction.
* @param _transaction OVM transaction to verify.
* @param _transactionBatchHeader Batch header for the provided transaction.
* @param _transactionProof Inclusion proof for the provided transaction.
* @return _verified Whether or not the transaction was included.
*/
function _verifyTransaction(
Lib_OVMCodec.Transaction memory _transaction,
Lib_OVMCodec.ChainBatchHeader memory _transactionBatchHeader,
Lib_OVMCodec.ChainInclusionProof memory _transactionProof
)
internal
view
returns (
bool _verified
)
{
return ovmCanonicalTransactionChain.verifyElement(
Lib_OVMCodec.encodeTransaction(_transaction),
_transactionBatchHeader,
_transactionProof
);
}
}
packages/contracts/build/contracts/OVM/verification/OVM_StateTransitioner.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
import { Lib_EthUtils } from "../../libraries/utils/Lib_EthUtils.sol";
import { Lib_EthMerkleTrie } from "../../libraries/trie/Lib_EthMerkleTrie.sol";
/* Interface Imports */
import { iOVM_StateTransitioner } from "../../iOVM/verification/iOVM_StateTransitioner.sol";
import { iOVM_ExecutionManager } from "../../iOVM/execution/iOVM_ExecutionManager.sol";
import { iOVM_StateManager } from "../../iOVM/execution/iOVM_StateManager.sol";
import { iOVM_StateManagerFactory } from "../../iOVM/execution/iOVM_StateManagerFactory.sol";
/**
* @title OVM_StateTransitioner
*/
contract OVM_StateTransitioner is iOVM_StateTransitioner, Lib_AddressResolver {
/*******************
* Data Structures *
*******************/
enum TransitionPhase {
PRE_EXECUTION,
POST_EXECUTION,
COMPLETE
}
/*******************************************
* Contract Variables: Contract References *
*******************************************/
iOVM_ExecutionManager internal ovmExecutionManager;
iOVM_StateManager internal ovmStateManager;
/*******************************************
* Contract Variables: Internal Accounting *
*******************************************/
bytes32 internal preStateRoot;
bytes32 internal postStateRoot;
TransitionPhase internal phase;
uint256 internal stateTransitionIndex;
bytes32 internal transactionHash;
/***************
* Constructor *
***************/
/**
* @param _libAddressManager Address of the Address Manager.
* @param _stateTransitionIndex Index of the state transition being verified.
* @param _preStateRoot State root before the transition was executed.
* @param _transactionHash Hash of the executed transaction.
*/
constructor(
address _libAddressManager,
uint256 _stateTransitionIndex,
bytes32 _preStateRoot,
bytes32 _transactionHash
)
Lib_AddressResolver(_libAddressManager)
{
stateTransitionIndex = _stateTransitionIndex;
preStateRoot = _preStateRoot;
postStateRoot = _preStateRoot;
transactionHash = _transactionHash;
ovmExecutionManager = iOVM_ExecutionManager(resolve("OVM_ExecutionManager"));
ovmStateManager = iOVM_StateManagerFactory(resolve("OVM_StateManagerFactory")).create(address(this));
}
/**********************
* Function Modifiers *
**********************/
/**
* Checks that a function is only run during a specific phase.
* @param _phase Phase the function must run within.
*/
modifier onlyDuringPhase(
TransitionPhase _phase
) {
require(
phase == _phase,
"Function must be called during the correct phase."
);
_;
}
/**********************************
* Public Functions: State Access *
**********************************/
/**
* Retrieves the state root before execution.
* @return _preStateRoot State root before execution.
*/
function getPreStateRoot()
override
public
view
returns (
bytes32 _preStateRoot
)
{
return preStateRoot;
}
/**
* Retrieves the state root after execution.
* @return _postStateRoot State root after execution.
*/
function getPostStateRoot()
override
public
view
returns (
bytes32 _postStateRoot
)
{
return postStateRoot;
}
/**
* Checks whether the transitioner is complete.
* @return _complete Whether or not the transition process is finished.
*/
function isComplete()
override
public
view
returns (
bool _complete
)
{
return phase == TransitionPhase.COMPLETE;
}
/***********************************
* Public Functions: Pre-Execution *
***********************************/
/**
* Allows a user to prove the initial state of a contract.
* @param _ovmContractAddress Address of the contract on the OVM.
* @param _account Claimed account state.
* @param _stateTrieWitness Proof of the account state.
*/
function proveContractState(
address _ovmContractAddress,
Lib_OVMCodec.Account memory _account,
bytes memory _stateTrieWitness
)
override
public
onlyDuringPhase(TransitionPhase.PRE_EXECUTION)
{
require(
_account.codeHash == Lib_EthUtils.getCodeHash(_account.ethAddress),
"Invalid code hash provided."
);
require(
Lib_EthMerkleTrie.proveAccountState(
_ovmContractAddress,
_account,
_stateTrieWitness,
preStateRoot
),
"Invalid account state provided."
);
ovmStateManager.putAccount(
_ovmContractAddress,
_account
);
}
/**
* Allows a user to prove the initial state of a contract storage slot.
* @param _ovmContractAddress Address of the contract on the OVM.
* @param _key Claimed account slot key.
* @param _value Claimed account slot value.
* @param _stateTrieWitness Proof of the account state.
* @param _storageTrieWitness Proof of the storage slot.
*/
function proveStorageSlot(
address _ovmContractAddress,
bytes32 _key,
bytes32 _value,
bytes memory _stateTrieWitness,
bytes memory _storageTrieWitness
)
override
public
onlyDuringPhase(TransitionPhase.PRE_EXECUTION)
{
require(
ovmStateManager.hasAccount(_ovmContractAddress) == true,
"Contract must be verified before proving a storage slot."
);
require(
Lib_EthMerkleTrie.proveAccountStorageSlotValue(
_ovmContractAddress,
_key,
_value,
_stateTrieWitness,
_storageTrieWitness,
preStateRoot
),
"Invalid account state provided."
);
ovmStateManager.putContractStorage(
_ovmContractAddress,
_key,
_value
);
}
/*******************************
* Public Functions: Execution *
*******************************/
/**
* Executes the state transition.
* @param _transaction OVM transaction to execute.
*/
function applyTransaction(
Lib_OVMCodec.Transaction memory _transaction
)
override
public
{
require(
Lib_OVMCodec.hashTransaction(_transaction) == transactionHash,
"Invalid transaction provided."
);
// TODO: Set state manager for EM here.
ovmStateManager.setExecutionManager(resolve("OVM_ExecutionManager"));
ovmExecutionManager.run(_transaction, address(ovmStateManager));
phase = TransitionPhase.POST_EXECUTION;
}
/************************************
* Public Functions: Post-Execution *
************************************/
/**
* Allows a user to commit the final state of a contract.
* @param _ovmContractAddress Address of the contract on the OVM.
* @param _account Claimed account state.
* @param _stateTrieWitness Proof of the account state.
*/
function commitContractState(
address _ovmContractAddress,
Lib_OVMCodec.Account memory _account,
bytes memory _stateTrieWitness
)
override
public
onlyDuringPhase(TransitionPhase.POST_EXECUTION)
{
require(
ovmStateManager.commitAccount(_ovmContractAddress) == true,
"Cannot commit an account that has not been changed."
);
postStateRoot = Lib_EthMerkleTrie.updateAccountState(
_ovmContractAddress,
_account,
_stateTrieWitness,
postStateRoot
);
}
/**
* Allows a user to commit the final state of a contract storage slot.
* @param _ovmContractAddress Address of the contract on the OVM.
* @param _key Claimed account slot key.
* @param _value Claimed account slot value.
* @param _stateTrieWitness Proof of the account state.
* @param _storageTrieWitness Proof of the storage slot.
*/
function commitStorageSlot(
address _ovmContractAddress,
bytes32 _key,
bytes32 _value,
bytes memory _stateTrieWitness,
bytes memory _storageTrieWitness
)
override
public
onlyDuringPhase(TransitionPhase.POST_EXECUTION)
{
require(
ovmStateManager.commitContractStorage(_ovmContractAddress, _key) == true,
"Cannot commit a storage slot that has not been changed."
);
postStateRoot = Lib_EthMerkleTrie.updateAccountStorageSlotValue(
_ovmContractAddress,
_key,
_value,
_stateTrieWitness,
_storageTrieWitness,
postStateRoot
);
}
/**********************************
* Public Functions: Finalization *
**********************************/
/**
* Finalizes the transition process.
*/
function completeTransition()
override
public
onlyDuringPhase(TransitionPhase.POST_EXECUTION)
{
require(
ovmStateManager.getTotalUncommittedAccounts() == 0,
"All accounts must be committed before completing a transition."
);
require(
ovmStateManager.getTotalUncommittedContractStorage() == 0,
"All storage must be committed before completing a transition."
);
phase = TransitionPhase.COMPLETE;
}
}
packages/contracts/build/contracts/OVM/verification/OVM_StateTransitionerFactory.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Interface Imports */
import { iOVM_StateTransitioner } from "../../iOVM/verification/iOVM_StateTransitioner.sol";
import { iOVM_StateTransitionerFactory } from "../../iOVM/verification/iOVM_StateTransitionerFactory.sol";
/* Contract Imports */
import { OVM_StateTransitioner } from "./OVM_StateTransitioner.sol";
/**
* @title OVM_StateTransitionerFactory
*/
contract OVM_StateTransitionerFactory is iOVM_StateTransitionerFactory {
/***************************************
* Public Functions: Contract Creation *
***************************************/
/**
* Creates a new OVM_StateTransitioner
* @param _libAddressManager Address of the Address Manager.
* @param _stateTransitionIndex Index of the state transition being verified.
* @param _preStateRoot State root before the transition was executed.
* @param _transactionHash Hash of the executed transaction.
* @return _ovmStateTransitioner New OVM_StateTransitioner instance.
*/
function create(
address _libAddressManager,
uint256 _stateTransitionIndex,
bytes32 _preStateRoot,
bytes32 _transactionHash
)
override
public
returns (
iOVM_StateTransitioner _ovmStateTransitioner
)
{
return new OVM_StateTransitioner(
_libAddressManager,
_stateTransitionIndex,
_preStateRoot,
_transactionHash
);
}
}
packages/contracts/build/contracts/iOVM/accounts/iOVM_ECDSAContractAccount.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/**
* @title iOVM_ECDSAContractAccount
*/
interface iOVM_ECDSAContractAccount {
/********************
* Public Functions *
********************/
function execute(
bytes memory _transaction,
Lib_OVMCodec.EOASignatureType _signatureType,
uint8 _v,
bytes32 _r,
bytes32 _s
) external returns (bool _success, bytes memory _returndata);
}
packages/contracts/build/contracts/iOVM/bridge/iOVM_BaseCrossDomainMessenger.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/**
* @title iOVM_BaseCrossDomainMessenger
*/
interface iOVM_BaseCrossDomainMessenger {
/********************
* Public Functions *
********************/
/**
* Sets the target messenger address.
* @param _targetMessengerAddress New messenger address.
*/
function setTargetMessengerAddress(
address _targetMessengerAddress
) external;
}
packages/contracts/build/contracts/iOVM/bridge/iOVM_L1CrossDomainMessenger.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/* Interface Imports */
import { iOVM_BaseCrossDomainMessenger } from "./iOVM_BaseCrossDomainMessenger.sol";
/**
* @title iOVM_L1CrossDomainMessenger
*/
interface iOVM_L1CrossDomainMessenger is iOVM_BaseCrossDomainMessenger {
/*******************
* Data Structures *
*******************/
struct L2MessageInclusionProof {
bytes32 stateRoot;
Lib_OVMCodec.ChainBatchHeader stateRootBatchHeader;
Lib_OVMCodec.ChainInclusionProof stateRootProof;
bytes stateTrieWitness;
bytes storageTrieWitness;
}
/********************
* Public Functions *
********************/
/**
* Relays a cross domain message to a contract.
* @param _target Target contract address.
* @param _sender Message sender address.
* @param _message Message to send to the target.
* @param _messageNonce Nonce for the provided message.
* @param _proof Inclusion proof for the given message.
*/
function relayMessage(
address _target,
address _sender,
bytes memory _message,
uint256 _messageNonce,
L2MessageInclusionProof memory _proof
) external;
/**
* Sends a cross domain message to the target messenger.
* @param _target Target contract address.
* @param _message Message to send to the target.
* @param _gasLimit Gas limit for the provided message.
*/
function sendMessage(
address _target,
bytes memory _message,
uint32 _gasLimit
) external;
/**
* Replays a cross domain message to the target messenger.
* @param _target Target contract address.
* @param _sender Original sender address.
* @param _message Message to send to the target.
* @param _messageNonce Nonce for the provided message.
* @param _gasLimit Gas limit for the provided message.
*/
function replayMessage(
address _target,
address _sender,
bytes memory _message,
uint256 _messageNonce,
uint32 _gasLimit
) external;
}
packages/contracts/build/contracts/iOVM/bridge/iOVM_L2CrossDomainMessenger.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Interface Imports */
import { iOVM_BaseCrossDomainMessenger } from "./iOVM_BaseCrossDomainMessenger.sol";
/**
* @title iOVM_L2CrossDomainMessenger
*/
interface iOVM_L2CrossDomainMessenger is iOVM_BaseCrossDomainMessenger {
/********************
* Public Functions *
********************/
/**
* Relays a cross domain message to a contract.
* @param _target Target contract address.
* @param _sender Message sender address.
* @param _message Message to send to the target.
* @param _messageNonce Nonce for the provided message.
*/
function relayMessage(
address _target,
address _sender,
bytes memory _message,
uint256 _messageNonce
) external;
/**
* Sends a cross domain message to the target messenger.
* @param _target Target contract address.
* @param _message Message to send to the target.
* @param _gasLimit Gas limit for the provided message.
*/
function sendMessage(
address _target,
bytes memory _message,
uint256 _gasLimit
) external;
}
packages/contracts/build/contracts/iOVM/chain/iOVM_BaseChain.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/**
* @title iOVM_BaseChain
*/
interface iOVM_BaseChain {
/*************************************
* Public Functions: Batch Retrieval *
*************************************/
function getTotalElements() external view returns (uint256 _totalElements);
function getTotalBatches() external view returns (uint256 _totalBatches);
/****************************************
* Public Functions: Batch Verification *
****************************************/
function verifyElement(
bytes calldata _element,
Lib_OVMCodec.ChainBatchHeader calldata _batchHeader,
Lib_OVMCodec.ChainInclusionProof calldata _proof
) external view returns (bool _verified);
}
packages/contracts/build/contracts/iOVM/chain/iOVM_CanonicalTransactionChain.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Interface Imports */
import { iOVM_BaseChain } from "./iOVM_BaseChain.sol";
/**
* @title iOVM_CanonicalTransactionChain
*/
interface iOVM_CanonicalTransactionChain is iOVM_BaseChain {
/****************************************
* Public Functions: Batch Manipulation *
****************************************/
function appendQueueBatch() external;
function appendSequencerBatch(bytes[] calldata _batch, uint256 _timestamp) external;
}
packages/contracts/build/contracts/iOVM/chain/iOVM_StateCommitmentChain.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Interface Imports */
import { iOVM_BaseChain } from "./iOVM_BaseChain.sol";
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/**
* @title iOVM_StateCommitmentChain
*/
interface iOVM_StateCommitmentChain is iOVM_BaseChain {
/****************************************
* Public Functions: Batch Manipulation *
****************************************/
function appendStateBatch(bytes32[] calldata _batch) external;
function deleteStateBatch(Lib_OVMCodec.ChainBatchHeader memory _batchHeader) external;
}
packages/contracts/build/contracts/iOVM/execution/iOVM_ExecutionManager.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
interface iOVM_ExecutionManager {
/**********
* Enums *
*********/
enum RevertFlag {
DID_NOT_REVERT,
OUT_OF_GAS,
INTENTIONAL_REVERT,
EXCEEDS_NUISANCE_GAS,
INVALID_STATE_ACCESS,
UNSAFE_BYTECODE,
CREATE_COLLISION,
STATIC_VIOLATION,
CREATE_EXCEPTION
}
enum GasMetadataKey {
CURRENT_EPOCH_START_TIMESTAMP,
CUMULATIVE_SEQUENCER_QUEUE_GAS,
CUMULATIVE_L1TOL2_QUEUE_GAS,
PREV_EPOCH_SEQUENCER_QUEUE_GAS,
PREV_EPOCH_L1TOL2_QUEUE_GAS
}
/***********
* Structs *
***********/
struct GasMeterConfig {
uint256 minTransactionGasLimit;
uint256 maxTransactionGasLimit;
uint256 maxGasPerQueuePerEpoch;
uint256 secondsPerEpoch;
}
struct GlobalContext {
uint256 ovmCHAINID;
}
struct TransactionContext {
Lib_OVMCodec.QueueOrigin ovmL1QUEUEORIGIN;
uint256 ovmTIMESTAMP;
uint256 ovmNUMBER;
uint256 ovmGASLIMIT;
uint256 ovmTXGASLIMIT;
address ovmL1TXORIGIN;
}
struct TransactionRecord {
uint256 ovmGasRefund;
}
struct MessageContext {
address ovmCALLER;
address ovmADDRESS;
bool isStatic;
bool isCreation;
}
struct MessageRecord {
uint256 nuisanceGasLeft;
RevertFlag revertFlag;
}
/************************************
* Transaction Execution Entrypoint *
************************************/
function run(
Lib_OVMCodec.Transaction calldata _transaction,
address _txStateManager
) external;
/*******************
* Context Opcodes *
*******************/
function ovmCALLER() external view returns (address _caller);
function ovmADDRESS() external view returns (address _address);
function ovmTIMESTAMP() external view returns (uint256 _timestamp);
function ovmNUMBER() external view returns (uint256 _number);
function ovmGASLIMIT() external view returns (uint256 _gasLimit);
function ovmCHAINID() external view returns (uint256 _chainId);
/**********************
* L2 Context Opcodes *
**********************/
function ovmL1QUEUEORIGIN() external view returns (Lib_OVMCodec.QueueOrigin _queueOrigin);
function ovmL1TXORIGIN() external view returns (address _l1TxOrigin);
/*******************
* Halting Opcodes *
*******************/
function ovmREVERT(bytes memory _data) external;
/*****************************
* Contract Creation Opcodes *
*****************************/
function ovmCREATE(bytes memory _bytecode) external returns (address _contract);
function ovmCREATE2(bytes memory _bytecode, bytes32 _salt) external returns (address _contract);
/*******************************
* Account Abstraction Opcodes *
******************************/
function ovmGETNONCE() external returns (uint256 _nonce);
function ovmSETNONCE(uint256 _nonce) external;
function ovmCREATEEOA(bytes32 _messageHash, uint8 _v, bytes32 _r, bytes32 _s) external;
/****************************
* Contract Calling Opcodes *
****************************/
function ovmCALL(uint256 _gasLimit, address _address, bytes memory _calldata) external returns (bool _success, bytes memory _returndata);
function ovmSTATICCALL(uint256 _gasLimit, address _address, bytes memory _calldata) external returns (bool _success, bytes memory _returndata);
function ovmDELEGATECALL(uint256 _gasLimit, address _address, bytes memory _calldata) external returns (bool _success, bytes memory _returndata);
/****************************
* Contract Storage Opcodes *
****************************/
function ovmSLOAD(bytes32 _key) external returns (bytes32 _value);
function ovmSSTORE(bytes32 _key, bytes32 _value) external;
/*************************
* Contract Code Opcodes *
*************************/
function ovmEXTCODECOPY(address _contract, uint256 _offset, uint256 _length) external returns (bytes memory _code);
function ovmEXTCODESIZE(address _contract) external returns (uint256 _size);
function ovmEXTCODEHASH(address _contract) external returns (bytes32 _hash);
/**************************************
* Public Functions: Execution Safety *
**************************************/
function safeCREATE(address _address, bytes memory _bytecode) external;
}
packages/contracts/build/contracts/iOVM/execution/iOVM_SafetyChecker.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/**
* @title iOVM_SafetyChecker
*/
interface iOVM_SafetyChecker {
/********************
* Public Functions *
********************/
function isBytecodeSafe(bytes memory _bytecode) external view returns (bool _safe);
}
packages/contracts/build/contracts/iOVM/execution/iOVM_StateManager.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/**
* @title iOVM_StateManager
*/
interface iOVM_StateManager {
/*******************
* Data Structures *
*******************/
enum ItemState {
ITEM_UNTOUCHED,
ITEM_LOADED,
ITEM_CHANGED,
ITEM_COMMITTED
}
/***************************
* Public Functions: Setup *
***************************/
function setExecutionManager(address _ovmExecutionManager) external;
/************************************
* Public Functions: Account Access *
************************************/
function putAccount(address _address, Lib_OVMCodec.Account memory _account) external;
function getAccount(address _address) external view returns (Lib_OVMCodec.Account memory _account);
function hasAccount(address _address) external view returns (bool _exists);
function hasEmptyAccount(address _address) external view returns (bool _exists);
function setAccountNonce(address _address, uint256 _nonce) external;
function getAccountNonce(address _address) external view returns (uint256 _nonce);
function getAccountEthAddress(address _address) external view returns (address _ethAddress);
function initPendingAccount(address _address) external;
function commitPendingAccount(address _address, address _ethAddress, bytes32 _codeHash) external;
function testAndSetAccountLoaded(address _address) external returns (bool _wasAccountAlreadyLoaded);
function testAndSetAccountChanged(address _address) external returns (bool _wasAccountAlreadyChanged);
function commitAccount(address _address) external returns (bool _wasAccountCommitted);
function incrementTotalUncommittedAccounts() external;
function getTotalUncommittedAccounts() external view returns (uint256 _total);
/************************************
* Public Functions: Storage Access *
************************************/
function putContractStorage(address _contract, bytes32 _key, bytes32 _value) external;
function getContractStorage(address _contract, bytes32 _key) external view returns (bytes32 _value);
function hasContractStorage(address _contract, bytes32 _key) external returns (bool _exists);
function testAndSetContractStorageLoaded(address _contract, bytes32 _key) external returns (bool _wasContractStorageAlreadyLoaded);
function testAndSetContractStorageChanged(address _contract, bytes32 _key) external returns (bool _wasContractStorageAlreadyChanged);
function commitContractStorage(address _contract, bytes32 _key) external returns (bool _wasContractStorageCommitted);
function incrementTotalUncommittedContractStorage() external;
function getTotalUncommittedContractStorage() external view returns (uint256 _total);
}
packages/contracts/build/contracts/iOVM/execution/iOVM_StateManagerFactory.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Contract Imports */
import { iOVM_StateManager } from "./iOVM_StateManager.sol";
/**
* @title iOVM_StateManagerFactory
*/
interface iOVM_StateManagerFactory {
/***************************************
* Public Functions: Contract Creation *
***************************************/
function create(
address _owner
)
external
returns (
iOVM_StateManager _ovmStateManager
);
}
packages/contracts/build/contracts/iOVM/precompiles/iOVM_DeployerWhitelist.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/**
* @title iOVM_DeployerWhitelist
*/
interface iOVM_DeployerWhitelist {
/********************
* Public Functions *
********************/
function initialize(address _owner, bool _allowArbitraryDeployment) external;
function setWhitelistedDeployer(address _deployer, bool _isWhitelisted) external;
function setOwner(address _newOwner) external;
function setAllowArbitraryDeployment(bool _allowArbitraryDeployment) external;
function enableArbitraryContractDeployment() external;
function isDeployerAllowed(address _deployer) external returns (bool _allowed);
}
packages/contracts/build/contracts/iOVM/precompiles/iOVM_L1MessageSender.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/**
* @title iOVM_L1MessageSender
*/
interface iOVM_L1MessageSender {
/********************
* Public Functions *
********************/
function getL1MessageSender() external returns (address _l1MessageSender);
}
packages/contracts/build/contracts/iOVM/precompiles/iOVM_L2ToL1MessagePasser.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/**
* @title iOVM_L2ToL1MessagePasser
*/
interface iOVM_L2ToL1MessagePasser {
/**********
* Events *
**********/
event L2ToL1Message(
uint _nonce,
address _sender,
bytes _data
);
/********************
* Public Functions *
********************/
function passMessageToL1(bytes memory _message) external;
}
packages/contracts/build/contracts/iOVM/queue/iOVM_BaseQueue.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/**
* @title iOVM_BaseQueue
*/
interface iOVM_BaseQueue {
/**********************************
* Public Functions: Queue Access *
**********************************/
function size() external view returns (uint256 _size);
function peek() external view returns (Lib_OVMCodec.QueueElement memory _element);
}
packages/contracts/build/contracts/iOVM/queue/iOVM_L1ToL2TransactionQueue.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/* Interface Imports */
import { iOVM_BaseQueue } from "./iOVM_BaseQueue.sol";
/**
* @title iOVM_L1ToL2TransactionQueue
*/
interface iOVM_L1ToL2TransactionQueue is iOVM_BaseQueue {
/****************************************
* Public Functions: Queue Manipulation *
****************************************/
function enqueue(address _target, uint256 _gasLimit, bytes memory _data) external;
function dequeue() external;
}
packages/contracts/build/contracts/iOVM/verification/iOVM_FraudVerifier.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/* Interface Imports */
import { iOVM_StateTransitioner } from "./iOVM_StateTransitioner.sol";
/**
* @title iOVM_FraudVerifier
*/
interface iOVM_FraudVerifier {
/***************************************
* Public Functions: Transition Status *
***************************************/
function getStateTransitioner(bytes32 _preStateRoot) external view returns (iOVM_StateTransitioner _transitioner);
/****************************************
* Public Functions: Fraud Verification *
****************************************/
function initializeFraudVerification(
bytes32 _preStateRoot,
Lib_OVMCodec.ChainBatchHeader calldata _preStateRootBatchHeader,
Lib_OVMCodec.ChainInclusionProof calldata _preStateRootProof,
Lib_OVMCodec.Transaction calldata _transaction,
Lib_OVMCodec.ChainBatchHeader calldata _transactionBatchHeader,
Lib_OVMCodec.ChainInclusionProof calldata _transactionProof
) external;
function finalizeFraudVerification(
bytes32 _preStateRoot,
Lib_OVMCodec.ChainBatchHeader calldata _preStateRootBatchHeader,
Lib_OVMCodec.ChainInclusionProof calldata _preStateRootProof,
bytes32 _postStateRoot,
Lib_OVMCodec.ChainBatchHeader calldata _postStateRootBatchHeader,
Lib_OVMCodec.ChainInclusionProof calldata _postStateRootProof
) external;
}
packages/contracts/build/contracts/iOVM/verification/iOVM_StateTransitioner.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../libraries/codec/Lib_OVMCodec.sol";
/**
* @title iOVM_StateTransitioner
*/
interface iOVM_StateTransitioner {
/**********************************
* Public Functions: State Access *
**********************************/
function getPreStateRoot() external view returns (bytes32 _preStateRoot);
function getPostStateRoot() external view returns (bytes32 _postStateRoot);
function isComplete() external view returns (bool _complete);
/***********************************
* Public Functions: Pre-Execution *
***********************************/
function proveContractState(
address _ovmContractAddress,
Lib_OVMCodec.Account calldata _account,
bytes calldata _stateTrieWitness
) external;
function proveStorageSlot(
address _ovmContractAddress,
bytes32 _key,
bytes32 _value,
bytes calldata _stateTrieWitness,
bytes calldata _storageTrieWitness
) external;
/*******************************
* Public Functions: Execution *
*******************************/
function applyTransaction(
Lib_OVMCodec.Transaction calldata _transaction
) external;
/************************************
* Public Functions: Post-Execution *
************************************/
function commitContractState(
address _ovmContractAddress,
Lib_OVMCodec.Account calldata _account,
bytes calldata _stateTrieWitness
) external;
function commitStorageSlot(
address _ovmContractAddress,
bytes32 _key,
bytes32 _value,
bytes calldata _stateTrieWitness,
bytes calldata _storageTrieWitness
) external;
/**********************************
* Public Functions: Finalization *
**********************************/
function completeTransition() external;
}
packages/contracts/build/contracts/iOVM/verification/iOVM_StateTransitionerFactory.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Contract Imports */
import { iOVM_StateTransitioner } from "./iOVM_StateTransitioner.sol";
/**
* @title iOVM_StateTransitionerFactory
*/
interface iOVM_StateTransitionerFactory {
/***************************************
* Public Functions: Contract Creation *
***************************************/
function create(
address _proxyManager,
uint256 _stateTransitionIndex,
bytes32 _preStateRoot,
bytes32 _transactionHash
)
external
returns (
iOVM_StateTransitioner _ovmStateTransitioner
);
}
packages/contracts/build/contracts/libraries/codec/Lib_OVMCodec.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol";
/**
* @title Lib_OVMCodec
*/
library Lib_OVMCodec {
/*********
* Enums *
*********/
enum EOASignatureType {
ETH_SIGNED_MESSAGE,
NATIVE_TRANSACTON
}
enum QueueOrigin {
SEQUENCER_QUEUE,
L1TOL2_QUEUE
}
/***********
* Structs *
***********/
struct Account {
uint256 nonce;
uint256 balance;
bytes32 storageRoot;
bytes32 codeHash;
address ethAddress;
bool isFresh;
}
struct EVMAccount {
uint256 nonce;
uint256 balance;
bytes32 storageRoot;
bytes32 codeHash;
}
struct ChainBatchHeader {
uint256 batchIndex;
bytes32 batchRoot;
uint256 batchSize;
uint256 prevTotalElements;
bytes extraData;
}
struct ChainInclusionProof {
uint256 index;
bytes32[] siblings;
}
struct Transaction {
uint256 timestamp;
uint256 number;
QueueOrigin l1QueueOrigin;
address l1Txorigin;
address entrypoint;
uint256 gasLimit;
bytes data;
}
struct ProofMatrix {
bool checkNonce;
bool checkBalance;
bool checkStorageRoot;
bool checkCodeHash;
}
struct QueueElement {
uint256 timestamp;
bytes32 batchRoot;
bool isL1ToL2Batch;
}
struct EOATransaction {
address target;
uint256 nonce;
uint256 gasLimit;
bytes data;
}
/*********************************************
* Internal Functions: Encoding and Decoding *
*********************************************/
/**
* Decodes an EOA transaction (i.e., native Ethereum RLP encoding).
* @param _transaction Encoded EOA transaction.
* @return _decoded Transaction decoded into a struct.
*/
function decodeEOATransaction(
bytes memory _transaction
)
internal
pure
returns (
EOATransaction memory _decoded
)
{
Lib_RLPReader.RLPItem[] memory decoded = Lib_RLPReader.toList(Lib_RLPReader.toRlpItem(_transaction));
return EOATransaction({
nonce: Lib_RLPReader.toUint(decoded[0]),
gasLimit: Lib_RLPReader.toUint(decoded[2]),
target: Lib_RLPReader.toAddress(decoded[3]),
data: Lib_RLPReader.toBytes(decoded[5])
});
}
/**
* Encodes a standard OVM transaction.
* @param _transaction OVM transaction to encode.
* @return _encoded Encoded transaction bytes.
*/
function encodeTransaction(
Transaction memory _transaction
)
internal
pure
returns (
bytes memory _encoded
)
{
return abi.encodePacked(
_transaction.timestamp,
_transaction.number,
_transaction.l1QueueOrigin,
_transaction.l1Txorigin,
_transaction.entrypoint,
_transaction.gasLimit,
_transaction.data
);
}
/**
* Hashes a standard OVM transaction.
* @param _transaction OVM transaction to encode.
* @return _hash Hashed transaction
*/
function hashTransaction(
Transaction memory _transaction
)
internal
pure
returns (
bytes32 _hash
)
{
return keccak256(encodeTransaction(_transaction));
}
}
packages/contracts/build/contracts/libraries/resolver/Lib_AddressManager.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/**
* @title Lib_AddressManager
*/
contract Lib_AddressManager {
/*******************************************
* Contract Variables: Internal Accounting *
*******************************************/
mapping (bytes32 => address) private addresses;
/********************
* Public Functions *
********************/
function setAddress(
string memory _name,
address _address
)
public
{
addresses[_getNameHash(_name)] = _address;
}
function getAddress(
string memory _name
)
public
view
returns (address)
{
return addresses[_getNameHash(_name)];
}
/**********************
* Internal Functions *
**********************/
function _getNameHash(
string memory _name
)
internal
pure
returns (
bytes32 _hash
)
{
return keccak256(abi.encodePacked(_name));
}
}
packages/contracts/build/contracts/libraries/resolver/Lib_AddressResolver.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Library Imports */
import { Lib_AddressManager } from "./Lib_AddressManager.sol";
/**
* @title Lib_AddressResolver
*/
contract Lib_AddressResolver {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
Lib_AddressManager internal libAddressManager;
/***************
* Constructor *
***************/
/**
* @param _libAddressManager Address of the Lib_AddressManager.
*/
constructor(
address _libAddressManager
)
public
{
libAddressManager = Lib_AddressManager(_libAddressManager);
}
/********************
* Public Functions *
********************/
function resolve(
string memory _name
)
public
view
returns (
address _contract
)
{
return libAddressManager.getAddress(_name);
}
}
packages/contracts/build/contracts/libraries/rlp/Lib_RLPReader.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/**
* @title RLPReader
* @author Hamdi Allam hamdi.allam97@gmail.com
*/
library Lib_RLPReader {
/*
* Data Structures
*/
struct RLPItem {
uint len;
uint memPtr;
}
/*
* Contract Constants
*/
uint8 constant private STRING_SHORT_START = 0x80;
uint8 constant private STRING_LONG_START = 0xb8;
uint8 constant private LIST_SHORT_START = 0xc0;
uint8 constant private LIST_LONG_START = 0xf8;
uint8 constant private WORD_SIZE = 32;
/*
* Public Functions
*/
/**
* @param item RLP encoded bytes
*/
function toRlpItem(
bytes memory item
)
internal
pure
returns (RLPItem memory)
{
uint memPtr;
assembly {
memPtr := add(item, 0x20)
}
return RLPItem(item.length, memPtr);
}
/**
* @param item RLP encoded bytes
*/
function rlpLen(
RLPItem memory item
)
internal
pure
returns (uint)
{
return item.len;
}
/**
* @param item RLP encoded bytes
*/
function payloadLen(
RLPItem memory item
)
internal
pure
returns (uint)
{
return item.len - _payloadOffset(item.memPtr);
}
/**
* @param item RLP encoded list in bytes
*/
function toList(
RLPItem memory item
)
internal
pure
returns (RLPItem[] memory result)
{
require(isList(item));
uint items = numItems(item);
result = new RLPItem[](items);
uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
uint dataLen;
for (uint i = 0; i < items; i++) {
dataLen = _itemLength(memPtr);
result[i] = RLPItem(dataLen, memPtr);
memPtr = memPtr + dataLen;
}
}
// @return indicator whether encoded payload is a list. negate this function call for isData.
function isList(
RLPItem memory item
)
internal
pure
returns (bool)
{
if (item.len == 0) return false;
uint8 byte0;
uint memPtr = item.memPtr;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < LIST_SHORT_START)
return false;
return true;
}
/** RLPItem conversions into data types **/
// @returns raw rlp encoding in bytes
function toRlpBytes(
RLPItem memory item
)
internal
pure
returns (bytes memory)
{
bytes memory result = new bytes(item.len);
if (result.length == 0) return result;
uint ptr;
assembly {
ptr := add(0x20, result)
}
copy(item.memPtr, ptr, item.len);
return result;
}
// any non-zero byte is considered true
function toBoolean(
RLPItem memory item
)
internal
pure
returns (bool)
{
require(item.len == 1);
uint result;
uint memPtr = item.memPtr;
assembly {
result := byte(0, mload(memPtr))
}
return result == 0 ? false : true;
}
function toAddress(
RLPItem memory item
)
internal
pure
returns (address)
{
// 1 byte for the length prefix
require(item.len == 21);
return address(toUint(item));
}
function toUint(
RLPItem memory item
)
internal
pure
returns (uint)
{
require(item.len > 0 && item.len <= 33);
uint offset = _payloadOffset(item.memPtr);
uint len = item.len - offset;
uint result;
uint memPtr = item.memPtr + offset;
assembly {
result := mload(memPtr)
// shfit to the correct location if neccesary
if lt(len, 32) {
result := div(result, exp(256, sub(32, len)))
}
}
return result;
}
// enforces 32 byte length
function toUintStrict(
RLPItem memory item
)
internal
pure
returns (uint)
{
// one byte prefix
require(item.len == 33);
uint result;
uint memPtr = item.memPtr + 1;
assembly {
result := mload(memPtr)
}
return result;
}
function toBytes(
RLPItem memory item
)
internal
pure
returns (bytes memory)
{
require(item.len > 0);
uint offset = _payloadOffset(item.memPtr);
uint len = item.len - offset; // data length
bytes memory result = new bytes(len);
uint destPtr;
assembly {
destPtr := add(0x20, result)
}
copy(item.memPtr + offset, destPtr, len);
return result;
}
/*
* Private Functions
*/
// @return number of payload items inside an encoded list.
function numItems(
RLPItem memory item
)
private
pure
returns (uint)
{
if (item.len == 0) return 0;
uint count = 0;
uint currPtr = item.memPtr + _payloadOffset(item.memPtr);
uint endPtr = item.memPtr + item.len;
while (currPtr < endPtr) {
currPtr = currPtr + _itemLength(currPtr); // skip over an item
count++;
}
return count;
}
// @return entire rlp item byte length
function _itemLength(
uint memPtr
)
private
pure
returns (uint len)
{
uint byte0;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < STRING_SHORT_START)
return 1;
else if (byte0 < STRING_LONG_START)
return byte0 - STRING_SHORT_START + 1;
else if (byte0 < LIST_SHORT_START) {
assembly {
let byteLen := sub(byte0, 0xb7) // number of bytes the actual length is
memPtr := add(memPtr, 1) // skip over the first byte
/* 32 byte word size */
let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len
len := add(dataLen, add(byteLen, 1))
}
}
else if (byte0 < LIST_LONG_START) {
return byte0 - LIST_SHORT_START + 1;
}
else {
assembly {
let byteLen := sub(byte0, 0xf7)
memPtr := add(memPtr, 1)
let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length
len := add(dataLen, add(byteLen, 1))
}
}
}
// @return number of bytes until the data
function _payloadOffset(
uint memPtr
)
private
pure
returns (uint)
{
uint byte0;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < STRING_SHORT_START)
return 0;
else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START))
return 1;
else if (byte0 < LIST_SHORT_START) // being explicit
return byte0 - (STRING_LONG_START - 1) + 1;
else
return byte0 - (LIST_LONG_START - 1) + 1;
}
/*
* @param src Pointer to source
* @param dest Pointer to destination
* @param len Amount of memory to copy from the source
*/
function copy(
uint src,
uint dest,
uint len
)
private
pure
{
if (len == 0) return;
// copy as many word sizes as possible
for (; len >= WORD_SIZE; len -= WORD_SIZE) {
assembly {
mstore(dest, mload(src))
}
src += WORD_SIZE;
dest += WORD_SIZE;
}
// left over bytes. Mask is used to remove unwanted bytes from the word
uint mask = 256 ** (WORD_SIZE - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask)) // zero out src
let destpart := and(mload(dest), mask) // retrieve the bytes
mstore(dest, or(destpart, srcpart))
}
}
}
\ No newline at end of file
packages/contracts/build/contracts/libraries/rlp/Lib_RLPWriter.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/**
* Source: https://github.com/omisego/plasma-mvp/blob/master/plasma/root_chain/contracts/RLPEncode.sol
* @title RLPEncode
* @dev A simple RLP encoding library.
* @author Bakaoh
*/
library Lib_RLPWriter {
/*
* Public Functions
*/
/**
* RLP encodes a byte string.
* @param self The byte string to encode.
* @return The RLP encoded string in bytes.
*/
function encodeBytes(
bytes memory self
)
internal
pure
returns (bytes memory)
{
bytes memory encoded;
if (self.length == 1 && uint8(self[0]) < 128) {
encoded = self;
} else {
encoded = concat(encodeLength(self.length, 128), self);
}
return encoded;
}
/**
* RLP encodes a list of RLP encoded byte byte strings.
* @param self The list of RLP encoded byte strings.
* @return The RLP encoded list of items in bytes.
*/
function encodeList(
bytes[] memory self
)
internal
pure
returns (bytes memory)
{
bytes memory list = flatten(self);
return concat(encodeLength(list.length, 192), list);
}
/**
* RLP encodes a string.
* @param self The string to encode.
* @return The RLP encoded string in bytes.
*/
function encodeString(
string memory self
)
internal
pure
returns (bytes memory)
{
return encodeBytes(bytes(self));
}
/**
* RLP encodes an address.
* @param self The address to encode.
* @return The RLP encoded address in bytes.
*/
function encodeAddress(
address self
)
internal
pure
returns (bytes memory)
{
bytes memory inputBytes;
assembly {
let m := mload(0x40)
mstore(add(m, 20), xor(0x140000000000000000000000000000000000000000, self))
mstore(0x40, add(m, 52))
inputBytes := m
}
return encodeBytes(inputBytes);
}
/**
* RLP encodes a uint.
* @param self The uint to encode.
* @return The RLP encoded uint in bytes.
*/
function encodeUint(
uint self
)
internal
pure
returns (bytes memory)
{
return encodeBytes(toBinary(self));
}
/**
* RLP encodes an int.
* @param self The int to encode.
* @return The RLP encoded int in bytes.
*/
function encodeInt(
int self
)
internal
pure
returns (bytes memory)
{
return encodeUint(uint(self));
}
/**
* RLP encodes a bool.
* @param self The bool to encode.
* @return The RLP encoded bool in bytes.
*/
function encodeBool(
bool self
)
internal
pure
returns (bytes memory)
{
bytes memory encoded = new bytes(1);
encoded[0] = (self ? bytes1(0x01) : bytes1(0x80));
return encoded;
}
/*
* Private Functions
*/
/**
* Encode the first byte, followed by 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 RLP encoded bytes.
*/
function encodeLength(
uint len,
uint offset
)
private
pure
returns (bytes memory)
{
bytes memory encoded;
if (len < 56) {
encoded = new bytes(1);
encoded[0] = byte(uint8(len) + uint8(offset));
} else {
uint lenLen;
uint i = 1;
while (len / i != 0) {
lenLen++;
i *= 256;
}
encoded = new bytes(lenLen + 1);
encoded[0] = byte(uint8(lenLen) + uint8(offset) + 55);
for(i = 1; i <= lenLen; i++) {
encoded[i] = byte(uint8((len / (256**(lenLen-i))) % 256));
}
}
return encoded;
}
/**
* Encode integer in big endian binary form with no leading zeroes.
* @notice TODO: This should be optimized with assembly to save gas costs.
* @param _x The integer to encode.
* @return RLP encoded bytes.
*/
function toBinary(
uint _x
)
private
pure
returns (bytes memory)
{
bytes memory b = new bytes(32);
assembly {
mstore(add(b, 32), _x)
}
uint i = 0;
for (; i < 32; i++) {
if (b[i] != 0) {
break;
}
}
bytes memory res = new bytes(32 - i);
for (uint j = 0; j < res.length; j++) {
res[j] = b[i++];
}
return res;
}
/**
* Copies a piece of memory to another location.
* @notice From: https://github.com/Arachnid/solidity-stringutils/blob/master/src/strings.sol.
* @param _dest Destination location.
* @param _src Source location.
* @param _len Length of memory to copy.
*/
function memcpy(
uint _dest,
uint _src,
uint _len
)
private
pure
{
uint dest = _dest;
uint src = _src;
uint len = _len;
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
/**
* Flattens a list of byte strings into one byte string.
* @notice From: https://github.com/sammayo/solidity-rlp-encoder/blob/master/RLPEncode.sol.
* @param _list List of byte strings to flatten.
* @return The flattened byte string.
*/
function flatten(
bytes[] memory _list
)
private
pure
returns (bytes memory)
{
if (_list.length == 0) {
return new bytes(0);
}
uint len;
uint i = 0;
for (; i < _list.length; i++) {
len += _list[i].length;
}
bytes memory flattened = new bytes(len);
uint flattenedPtr;
assembly { flattenedPtr := add(flattened, 0x20) }
for(i = 0; i < _list.length; i++) {
bytes memory item = _list[i];
uint listPtr;
assembly { listPtr := add(item, 0x20)}
memcpy(flattenedPtr, listPtr, item.length);
flattenedPtr += _list[i].length;
}
return flattened;
}
/**
* Concatenates two bytes.
* @notice From: https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol.
* @param _preBytes First byte string.
* @param _postBytes Second byte string.
* @return Both byte string combined.
*/
function concat(
bytes memory _preBytes,
bytes memory _postBytes
)
private
pure
returns (bytes memory)
{
bytes memory tempBytes;
assembly {
tempBytes := mload(0x40)
let length := mload(_preBytes)
mstore(tempBytes, length)
let mc := add(tempBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_preBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
length := mload(_postBytes)
mstore(tempBytes, add(length, mload(tempBytes)))
mc := end
end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(0x40, and(
add(add(end, iszero(add(length, mload(_preBytes)))), 31),
not(31)
))
}
return tempBytes;
}
}
\ No newline at end of file
packages/contracts/build/contracts/libraries/trie/Lib_EthMerkleTrie.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_SecureMerkleTrie } from "./Lib_SecureMerkleTrie.sol";
import { Lib_OVMCodec } from "../codec/Lib_OVMCodec.sol";
import { Lib_ByteUtils } from "../utils/Lib_ByteUtils.sol";
import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol";
import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol";
/**
* @title Lib_EthMerkleTrie
*/
library Lib_EthMerkleTrie {
/**********************
* Contract Constants *
**********************/
bytes constant private RLP_NULL_BYTES = hex'80';
bytes32 constant private BYTES32_NULL = bytes32('');
uint256 constant private UINT256_NULL = uint256(0);
/*************************************
* Internal Functions: Storage Slots *
*************************************/
/**
* @notice Verifies a proof for the value of an account storage slot.
* @param _address Address of the contract account.
* @param _key Key for the storage slot.
* @param _value Value for the storage slot.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _storageTrieWitness Inclusion proof for the specific storage
* slot associated with the given key.
* @param _stateTrieRoot Known root of the state trie.
* @return `true` if the k/v pair is included, `false` otherwise.
*/
function proveAccountStorageSlotValue(
address _address,
bytes32 _key,
bytes32 _value,
bytes memory _stateTrieWitness,
bytes memory _storageTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bool)
{
// Retrieve the current storage root.
Lib_OVMCodec.EVMAccount memory accountState = getAccountState(
_address,
_stateTrieWitness,
_stateTrieRoot
);
// Verify inclusion of the given k/v pair in the storage trie.
return Lib_SecureMerkleTrie.verifyInclusionProof(
abi.encodePacked(_key),
abi.encodePacked(_value),
_storageTrieWitness,
accountState.storageRoot
);
}
/**
* @notice Updates the value for a given account storage slot.
* @param _address Address of the contract account.
* @param _key Key for the storage slot.
* @param _value New value for the storage slot.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _storageTrieWitness Inclusion proof for the specific storage
* slot associated with the given key.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function updateAccountStorageSlotValue(
address _address,
bytes32 _key,
bytes32 _value,
bytes memory _stateTrieWitness,
bytes memory _storageTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bytes32)
{
// Retreive the old storage root.
Lib_OVMCodec.EVMAccount memory accountState = getAccountState(
_address,
_stateTrieWitness,
_stateTrieRoot
);
// Generate a new storage root.
accountState.storageRoot = Lib_SecureMerkleTrie.update(
abi.encodePacked(_key),
abi.encodePacked(_value),
_storageTrieWitness,
accountState.storageRoot
);
// Update the state trie with the new storage root.
return setAccountState(
accountState,
_address,
_stateTrieWitness,
_stateTrieRoot
);
}
/**************************************
* Internal Functions: Account Proofs *
*************************************/
/**
* @notice Verifies a proof of the current state for a given account.
* @param _address Address of the target account.
* @param _accountState Account state object to verify.
* @param _proofMatrix Matrix of fields to verify or ignore.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return `true` if the given account state is valid, `false` otherwise.
*/
function proveAccountState(
address _address,
Lib_OVMCodec.EVMAccount memory _accountState,
Lib_OVMCodec.ProofMatrix memory _proofMatrix,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bool)
{
// Pull the current account state.
Lib_OVMCodec.EVMAccount memory accountState = getAccountState(
_address,
_stateTrieWitness,
_stateTrieRoot
);
// Check each provided component conditionally.
return (
(!_proofMatrix.checkNonce || accountState.nonce == _accountState.nonce) &&
(!_proofMatrix.checkBalance || accountState.balance == _accountState.balance) &&
(!_proofMatrix.checkStorageRoot || accountState.storageRoot == _accountState.storageRoot) &&
(!_proofMatrix.checkCodeHash || accountState.codeHash == _accountState.codeHash)
);
}
/**
* @notice Verifies a proof of the current state for a given account.
* @param _address Address of the target account.
* @param _accountState Account state object to verify.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return `true` if the given account state is valid, `false` otherwise.
*/
function proveAccountState(
address _address,
Lib_OVMCodec.EVMAccount memory _accountState,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bool)
{
return proveAccountState(
_address,
_accountState,
Lib_OVMCodec.ProofMatrix({
checkNonce: true,
checkBalance: true,
checkStorageRoot: true,
checkCodeHash: true
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Verifies a proof of the current state for a given account.
* @param _address Address of the target account.
* @param _accountState Account state object to verify.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return `true` if the given account state is valid, `false` otherwise.
*/
function proveAccountState(
address _address,
Lib_OVMCodec.Account memory _accountState,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bool)
{
return proveAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: _accountState.nonce,
balance: _accountState.balance,
storageRoot: _accountState.storageRoot,
codeHash: _accountState.codeHash
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Verifies a proof of the account nonce.
* @param _address Address of the target account.
* @param _nonce Account transaction nonce.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return `true` if the given nonce is valid, `false` otherwise.
*/
function proveAccountNonce(
address _address,
uint256 _nonce,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bool)
{
return proveAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: _nonce,
balance: UINT256_NULL,
storageRoot: BYTES32_NULL,
codeHash: BYTES32_NULL
}),
Lib_OVMCodec.ProofMatrix({
checkNonce: true,
checkBalance: false,
checkStorageRoot: false,
checkCodeHash: false
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Verifies a proof of the account balance.
* @param _address Address of the target account.
* @param _balance Account balance in wei.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return `true` if the given balance is valid, `false` otherwise.
*/
function proveAccountBalance(
address _address,
uint256 _balance,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bool)
{
return proveAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: UINT256_NULL,
balance: _balance,
storageRoot: BYTES32_NULL,
codeHash: BYTES32_NULL
}),
Lib_OVMCodec.ProofMatrix({
checkNonce: false,
checkBalance: true,
checkStorageRoot: false,
checkCodeHash: false
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Verifies a proof of the account storage root.
* @param _address Address of the target account.
* @param _storageRoot Account storage root, empty if EOA.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return `true` if the given storage root is valid, `false` otherwise.
*/
function proveAccountStorageRoot(
address _address,
bytes32 _storageRoot,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bool)
{
return proveAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: UINT256_NULL,
balance: UINT256_NULL,
storageRoot: _storageRoot,
codeHash: BYTES32_NULL
}),
Lib_OVMCodec.ProofMatrix({
checkNonce: false,
checkBalance: false,
checkStorageRoot: true,
checkCodeHash: false
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Verifies a proof of the account code hash.
* @param _address Address of the target account.
* @param _codeHash Account code hash, empty if EOA.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return `true` if the given code hash is valid, `false` otherwise.
*/
function proveAccountCodeHash(
address _address,
bytes32 _codeHash,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bool)
{
return proveAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: UINT256_NULL,
balance: UINT256_NULL,
storageRoot: BYTES32_NULL,
codeHash: _codeHash
}),
Lib_OVMCodec.ProofMatrix({
checkNonce: false,
checkBalance: false,
checkStorageRoot: false,
checkCodeHash: true
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/***************************************
* Internal Functions: Account Updates *
***************************************/
/**
* @notice Updates the current state for a given account.
* @param _address Address of the target account.
* @param _accountState Account state to insert.
* @param _proofMatrix Matrix of fields to update or ignore.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function updateAccountState(
address _address,
Lib_OVMCodec.EVMAccount memory _accountState,
Lib_OVMCodec.ProofMatrix memory _proofMatrix,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bytes32)
{
Lib_OVMCodec.EVMAccount memory newAccountState = _accountState;
// If the user has provided everything, don't bother pulling the
// current account state.
if (
!_proofMatrix.checkNonce ||
!_proofMatrix.checkBalance ||
!_proofMatrix.checkStorageRoot ||
!_proofMatrix.checkCodeHash
) {
// Pull the old account state.
Lib_OVMCodec.EVMAccount memory oldAccountState = getAccountState(
_address,
_stateTrieWitness,
_stateTrieRoot
);
// Conditionally update elements that haven't been provided with
// elements from the old account state.
if (!_proofMatrix.checkNonce) {
newAccountState.nonce = oldAccountState.nonce;
}
if (!_proofMatrix.checkBalance) {
newAccountState.balance = oldAccountState.balance;
}
if (!_proofMatrix.checkStorageRoot) {
newAccountState.storageRoot = oldAccountState.storageRoot;
}
if (!_proofMatrix.checkCodeHash) {
newAccountState.codeHash = oldAccountState.codeHash;
}
}
// Update the account state.
return setAccountState(
newAccountState,
_address,
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Updates the current state for a given account.
* @param _address Address of the target account.
* @param _accountState Account state to insert.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function updateAccountState(
address _address,
Lib_OVMCodec.EVMAccount memory _accountState,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bytes32)
{
return updateAccountState(
_address,
_accountState,
Lib_OVMCodec.ProofMatrix({
checkNonce: true,
checkBalance: true,
checkStorageRoot: true,
checkCodeHash: true
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Updates the current state for a given account.
* @param _address Address of the target account.
* @param _accountState Account state to insert.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function updateAccountState(
address _address,
Lib_OVMCodec.Account memory _accountState,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bytes32)
{
return updateAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: _accountState.nonce,
balance: _accountState.balance,
storageRoot: _accountState.storageRoot,
codeHash: _accountState.codeHash
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Updates an account nonce.
* @param _address Address of the target account.
* @param _nonce New account transaction nonce.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function updateAccountNonce(
address _address,
uint256 _nonce,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bytes32)
{
return updateAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: _nonce,
balance: UINT256_NULL,
storageRoot: BYTES32_NULL,
codeHash: BYTES32_NULL
}),
Lib_OVMCodec.ProofMatrix({
checkNonce: true,
checkBalance: false,
checkStorageRoot: false,
checkCodeHash: false
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Updates an account balance.
* @param _address Address of the target account.
* @param _balance New account balance in wei.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function updateAccountBalance(
address _address,
uint256 _balance,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bytes32)
{
return updateAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: UINT256_NULL,
balance: _balance,
storageRoot: BYTES32_NULL,
codeHash: BYTES32_NULL
}),
Lib_OVMCodec.ProofMatrix({
checkNonce: false,
checkBalance: true,
checkStorageRoot: false,
checkCodeHash: false
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Updates an account storage root.
* @param _address Address of the target account.
* @param _storageRoot New account storage root, empty if EOA.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function updateAccountStorageRoot(
address _address,
bytes32 _storageRoot,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bytes32)
{
return updateAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: UINT256_NULL,
balance: UINT256_NULL,
storageRoot: _storageRoot,
codeHash: BYTES32_NULL
}),
Lib_OVMCodec.ProofMatrix({
checkNonce: false,
checkBalance: false,
checkStorageRoot: true,
checkCodeHash: false
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/**
* @notice Updates an account code hash.
* @param _address Address of the target account.
* @param _codeHash New account code hash, empty if EOA.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function updateAccountCodeHash(
address _address,
bytes32 _codeHash,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
internal
view
returns (bytes32)
{
return updateAccountState(
_address,
Lib_OVMCodec.EVMAccount({
nonce: UINT256_NULL,
balance: UINT256_NULL,
storageRoot: BYTES32_NULL,
codeHash: _codeHash
}),
Lib_OVMCodec.ProofMatrix({
checkNonce: false,
checkBalance: false,
checkStorageRoot: false,
checkCodeHash: true
}),
_stateTrieWitness,
_stateTrieRoot
);
}
/*********************
* Private Functions *
*********************/
/**
* @notice Decodes an RLP-encoded account state into a useful struct.
* @param _encodedAccountState RLP-encoded account state.
* @return Account state struct.
*/
function decodeAccountState(
bytes memory _encodedAccountState
)
private
view
returns (Lib_OVMCodec.EVMAccount memory)
{
Lib_RLPReader.RLPItem[] memory accountState = Lib_RLPReader.toList(Lib_RLPReader.toRlpItem(_encodedAccountState));
return Lib_OVMCodec.EVMAccount({
nonce: Lib_RLPReader.toUint(accountState[0]),
balance: Lib_RLPReader.toUint(accountState[1]),
storageRoot: Lib_ByteUtils.toBytes32(Lib_RLPReader.toBytes(accountState[2])),
codeHash: Lib_ByteUtils.toBytes32(Lib_RLPReader.toBytes(accountState[3]))
});
}
/**
* @notice RLP-encodes an account state struct.
* @param _accountState Account state struct.
* @return RLP-encoded account state.
*/
function encodeAccountState(
Lib_OVMCodec.EVMAccount memory _accountState
)
private
view
returns (bytes memory)
{
bytes[] memory raw = new bytes[](4);
// Unfortunately we can't create this array outright because
// RLPWriter.encodeList will reject fixed-size arrays. Assigning
// index-by-index circumvents this issue.
raw[0] = Lib_RLPWriter.encodeUint(_accountState.nonce);
raw[1] = Lib_RLPWriter.encodeUint(_accountState.balance);
raw[2] = _accountState.storageRoot == 0 ? RLP_NULL_BYTES : Lib_RLPWriter.encodeBytes(abi.encodePacked(_accountState.storageRoot));
raw[3] = _accountState.codeHash == 0 ? RLP_NULL_BYTES : Lib_RLPWriter.encodeBytes(abi.encodePacked(_accountState.codeHash));
return Lib_RLPWriter.encodeList(raw);
}
/**
* @notice Retrieves the current account state and converts into a struct.
* @param _address Account address.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
*/
function getAccountState(
address _address,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
private
view
returns (Lib_OVMCodec.EVMAccount memory)
{
Lib_OVMCodec.EVMAccount memory DEFAULT_ACCOUNT_STATE = Lib_OVMCodec.EVMAccount({
nonce: UINT256_NULL,
balance: UINT256_NULL,
storageRoot: keccak256(hex'80'),
codeHash: keccak256(hex'')
});
(
bool exists,
bytes memory encodedAccountState
) = Lib_SecureMerkleTrie.get(
abi.encodePacked(_address),
_stateTrieWitness,
_stateTrieRoot
);
return exists ? decodeAccountState(encodedAccountState) : DEFAULT_ACCOUNT_STATE;
}
/**
* @notice Updates the current account state for a given address.
* @param _accountState New account state, as a struct.
* @param _address Account address.
* @param _stateTrieWitness Inclusion proof for the account state within
* the state trie.
* @param _stateTrieRoot Known root of the state trie.
* @return Root hash of the updated state trie.
*/
function setAccountState(
Lib_OVMCodec.EVMAccount memory _accountState,
address _address,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
private
view
returns (bytes32)
{
bytes memory encodedAccountState = encodeAccountState(_accountState);
return Lib_SecureMerkleTrie.update(
abi.encodePacked(_address),
encodedAccountState,
_stateTrieWitness,
_stateTrieRoot
);
}
}
\ No newline at end of file
packages/contracts/build/contracts/libraries/trie/Lib_MerkleTrie.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Library Imports */
import { Lib_ByteUtils } from "../utils/Lib_ByteUtils.sol";
import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol";
import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol";
/**
* @title Lib_MerkleTrie
*/
library Lib_MerkleTrie {
/*******************
* Data Structures *
*******************/
enum NodeType {
BranchNode,
ExtensionNode,
LeafNode
}
struct TrieNode {
bytes encoded;
Lib_RLPReader.RLPItem[] decoded;
}
/**********************
* Contract Constants *
**********************/
// TREE_RADIX determines the number of elements per branch node.
uint256 constant TREE_RADIX = 16;
// Branch nodes have TREE_RADIX elements plus an additional `value` slot.
uint256 constant BRANCH_NODE_LENGTH = TREE_RADIX + 1;
// Leaf nodes and extension nodes always have two elements, a `path` and a `value`.
uint256 constant LEAF_OR_EXTENSION_NODE_LENGTH = 2;
// Prefixes are prepended to the `path` within a leaf or extension node and
// allow us to differentiate between the two node types. `ODD` or `EVEN` is
// determined by the number of nibbles within the unprefixed `path`. If the
// number of nibbles if even, we need to insert an extra padding nibble so
// the resulting prefixed `path` has an even number of nibbles.
uint8 constant PREFIX_EXTENSION_EVEN = 0;
uint8 constant PREFIX_EXTENSION_ODD = 1;
uint8 constant PREFIX_LEAF_EVEN = 2;
uint8 constant PREFIX_LEAF_ODD = 3;
// Just a utility constant. RLP represents `NULL` as 0x80.
bytes1 constant RLP_NULL = bytes1(0x80);
bytes constant RLP_NULL_BYTES = hex'80';
/**********************
* Internal Functions *
**********************/
/**
* @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 `true` if the k/v pair exists in the trie, `false` otherwise.
*/
function verifyInclusionProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
internal
view
returns (
bool
)
{
return _verifyProof(_key, _value, _proof, _root, true);
}
/**
* @notice Verifies a proof that a given key/value pair is *not* 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 node *nearest* the
* target node. We effectively need to show that either the key exists and
* its value differs, or the key does not exist at all.
* @param _root Known root of the Merkle trie. Used to verify that the
* included proof is correctly constructed.
* @return `true` if the k/v pair is absent in the trie, `false` otherwise.
*/
function verifyExclusionProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
internal
view
returns (
bool
)
{
return _verifyProof(_key, _value, _proof, _root, false);
}
/**
* @notice Updates a Merkle trie and returns a new root hash.
* @param _key Key of the node to update, as a hex string.
* @param _value Value of the node to update, as a hex string.
* @param _proof Merkle trie inclusion proof for the node *nearest* the
* target node. If the key exists, we can simply update the value.
* Otherwise, we need to modify the trie to handle the new k/v pair.
* @param _root Known root of the Merkle trie. Used to verify that the
* included proof is correctly constructed.
* @return Root hash of the newly constructed trie.
*/
function update(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
internal
view
returns (
bytes32
)
{
TrieNode[] memory proof = _parseProof(_proof);
(uint256 pathLength, bytes memory keyRemainder, ) = _walkNodePath(proof, _key, _root);
TrieNode[] memory newPath = _getNewPath(proof, pathLength, keyRemainder, _value);
return _getUpdatedTrieRoot(newPath, _key);
}
/**
* @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 Whether the node exists, value associated with the key if so.
*/
function get(
bytes memory _key,
bytes memory _proof,
bytes32 _root
)
internal
view
returns (
bool,
bytes memory
)
{
TrieNode[] memory proof = _parseProof(_proof);
(uint256 pathLength, bytes memory keyRemainder, ) = _walkNodePath(proof, _key, _root);
bool exists = keyRemainder.length == 0;
bytes memory value = exists ? _getNodeValue(proof[pathLength - 1]) : bytes('');
return (
exists,
value
);
}
/**
* Computes the root hash for a trie with a single node.
* @param _key Key for the single node.
* @param _value Value for the single node.
* @return Hash of the trie.
*/
function getSingleNodeRootHash(
bytes memory _key,
bytes memory _value
)
internal
view
returns (
bytes32
)
{
return keccak256(_makeLeafNode(
_key,
_value
).encoded);
}
/*********************
* Private Functions *
*********************/
/**
* @notice Utility function that handles verification of inclusion or
* exclusion proofs. Since the verification methods are almost identical,
* it's easier to shove this into a single function.
* @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 node *nearest* the
* target node. If we're proving explicit inclusion, the nearest node
* should be the target node.
* @param _root Known root of the Merkle trie. Used to verify that the
* included proof is correctly constructed.
* @param _inclusion Whether to check for inclusion or exclusion.
* @return `true` if the k/v pair is (in/not in) the trie, `false` otherwise.
*/
function _verifyProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root,
bool _inclusion
)
private
view
returns (
bool
)
{
TrieNode[] memory proof = _parseProof(_proof);
(uint256 pathLength, bytes memory keyRemainder, bool isFinalNode) = _walkNodePath(proof, _key, _root);
if (_inclusion) {
// Included leaf nodes should have no key remainder, values should match.
return (
keyRemainder.length == 0 &&
Lib_ByteUtils.equal(_getNodeValue(proof[pathLength - 1]), _value)
);
} else {
// If there's no key remainder then a leaf with the given key exists and the value should differ.
// Otherwise, we need to make sure that we've hit a dead end.
return (
(keyRemainder.length == 0 && !Lib_ByteUtils.equal(_getNodeValue(proof[pathLength - 1]), _value)) ||
(keyRemainder.length != 0 && isFinalNode)
);
}
}
/**
* @notice Walks through a proof using a provided key.
* @param _proof Inclusion proof to walk through.
* @param _key Key to use for the walk.
* @param _root Known root of the trie.
* @return (
* Length of the final path;
* Portion of the key remaining after the walk;
* Whether or not we've hit a dead end;
* )
*/
function _walkNodePath(
TrieNode[] memory _proof,
bytes memory _key,
bytes32 _root
)
private
view
returns (
uint256,
bytes memory,
bool
)
{
uint256 pathLength = 0;
bytes memory key = Lib_ByteUtils.toNibbles(_key);
bytes32 currentNodeID = _root;
uint256 currentKeyIndex = 0;
uint256 currentKeyIncrement = 0;
TrieNode memory currentNode;
// Proof is top-down, so we start at the first element (root).
for (uint256 i = 0; i < _proof.length; i++) {
currentNode = _proof[i];
currentKeyIndex += currentKeyIncrement;
// Keep track of the proof elements we actually need.
// It's expensive to resize arrays, so this simply reduces gas costs.
pathLength += 1;
if (currentKeyIndex == 0) {
// First proof element is always the root node.
require(
keccak256(currentNode.encoded) == currentNodeID,
"Invalid root hash"
);
} else if (currentNode.encoded.length >= 32) {
// Nodes 32 bytes or larger are hashed inside branch nodes.
require(
keccak256(currentNode.encoded) == currentNodeID,
"Invalid large internal hash"
);
} else {
// Nodes smaller than 31 bytes aren't hashed.
require(
Lib_ByteUtils.toBytes32(currentNode.encoded) == currentNodeID,
"Invalid internal node hash"
);
}
if (currentNode.decoded.length == BRANCH_NODE_LENGTH) {
if (currentKeyIndex == key.length) {
// We've hit the end of the key, meaning the value should be within this branch node.
break;
} 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]);
Lib_RLPReader.RLPItem memory nextNode = currentNode.decoded[branchKey];
currentNodeID = _getNodeID(nextNode);
currentKeyIncrement = 1;
continue;
}
} 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 = Lib_ByteUtils.slice(path, offset);
bytes memory keyRemainder = Lib_ByteUtils.slice(key, currentKeyIndex);
uint256 sharedNibbleLength = _getSharedNibbleLength(pathRemainder, keyRemainder);
if (prefix == PREFIX_LEAF_EVEN || prefix == PREFIX_LEAF_ODD) {
if (
pathRemainder.length == sharedNibbleLength &&
keyRemainder.length == sharedNibbleLength
) {
// The key within this leaf matches our key exactly.
// Increment the key index to reflect that we have no remainder.
currentKeyIndex += sharedNibbleLength;
}
// We've hit a leaf node, so our next node should be NULL.
currentNodeID = bytes32(RLP_NULL);
break;
} else if (prefix == PREFIX_EXTENSION_EVEN || prefix == PREFIX_EXTENSION_ODD) {
if (sharedNibbleLength == 0) {
// Our extension node doesn't share any part of our key.
// We've hit the end of this path, updates will need to modify this extension.
currentNodeID = bytes32(RLP_NULL);
break;
} else {
// Our extension shares some nibbles.
// Carry on to the next node.
currentNodeID = _getNodeID(currentNode.decoded[1]);
currentKeyIncrement = sharedNibbleLength;
continue;
}
}
}
}
// If our node ID is NULL, then we're at a dead end.
bool isFinalNode = currentNodeID == bytes32(RLP_NULL);
return (pathLength, Lib_ByteUtils.slice(key, currentKeyIndex), isFinalNode);
}
/**
* @notice Creates new nodes to support a k/v pair insertion into a given
* Merkle trie path.
* @param _path Path to the node nearest the k/v pair.
* @param _pathLength Length of the path. Necessary because the provided
* path may include additional nodes (e.g., it comes directly from a proof)
* and we can't resize in-memory arrays without costly duplication.
* @param _keyRemainder Portion of the initial key that must be inserted
* into the trie.
* @param _value Value to insert at the given key.
* @return A new path with the inserted k/v pair and extra supporting nodes.
*/
function _getNewPath(
TrieNode[] memory _path,
uint256 _pathLength,
bytes memory _keyRemainder,
bytes memory _value
)
private
view
returns (
TrieNode[] memory
)
{
bytes memory keyRemainder = _keyRemainder;
// Most of our logic depends on the status of the last node in the path.
TrieNode memory lastNode = _path[_pathLength - 1];
NodeType lastNodeType = _getNodeType(lastNode);
// Create an array for newly created nodes.
// We need up to three new nodes, depending on the contents of the last node.
// Since array resizing is expensive, we'll keep track of the size manually.
// We're using an explicit `totalNewNodes += 1` after insertions for clarity.
TrieNode[] memory newNodes = new TrieNode[](3);
uint256 totalNewNodes = 0;
if (keyRemainder.length == 0 && lastNodeType == NodeType.LeafNode) {
// We've found a leaf node with the given key.
// Simply need to update the value of the node to match.
newNodes[totalNewNodes] = _makeLeafNode(_getNodeKey(lastNode), _value);
totalNewNodes += 1;
} else if (lastNodeType == NodeType.BranchNode) {
if (keyRemainder.length == 0) {
// We've found a branch node with the given key.
// Simply need to update the value of the node to match.
newNodes[totalNewNodes] = _editBranchValue(lastNode, _value);
totalNewNodes += 1;
} else {
// We've found a branch node, but it doesn't contain our key.
// Reinsert the old branch for now.
newNodes[totalNewNodes] = lastNode;
totalNewNodes += 1;
// Create a new leaf node, slicing our remainder since the first byte points
// to our branch node.
newNodes[totalNewNodes] = _makeLeafNode(Lib_ByteUtils.slice(keyRemainder, 1), _value);
totalNewNodes += 1;
}
} else {
// Our last node is either an extension node or a leaf node with a different key.
bytes memory lastNodeKey = _getNodeKey(lastNode);
uint256 sharedNibbleLength = _getSharedNibbleLength(lastNodeKey, keyRemainder);
if (sharedNibbleLength != 0) {
// We've got some shared nibbles between the last node and our key remainder.
// We'll need to insert an extension node that covers these shared nibbles.
bytes memory nextNodeKey = Lib_ByteUtils.slice(lastNodeKey, 0, sharedNibbleLength);
newNodes[totalNewNodes] = _makeExtensionNode(nextNodeKey, _getNodeHash(_value));
totalNewNodes += 1;
// Cut down the keys since we've just covered these shared nibbles.
lastNodeKey = Lib_ByteUtils.slice(lastNodeKey, sharedNibbleLength);
keyRemainder = Lib_ByteUtils.slice(keyRemainder, sharedNibbleLength);
}
// Create an empty branch to fill in.
TrieNode memory newBranch = _makeEmptyBranchNode();
if (lastNodeKey.length == 0) {
// Key remainder was larger than the key for our last node.
// The value within our last node is therefore going to be shifted into
// a branch value slot.
newBranch = _editBranchValue(newBranch, _getNodeValue(lastNode));
} else {
// Last node key was larger than the key remainder.
// We're going to modify some index of our branch.
uint8 branchKey = uint8(lastNodeKey[0]);
// Move on to the next nibble.
lastNodeKey = Lib_ByteUtils.slice(lastNodeKey, 1);
if (lastNodeType == NodeType.LeafNode) {
// We're dealing with a leaf node.
// We'll modify the key and insert the old leaf node into the branch index.
TrieNode memory modifiedLastNode = _makeLeafNode(lastNodeKey, _getNodeValue(lastNode));
newBranch = _editBranchIndex(newBranch, branchKey, _getNodeHash(modifiedLastNode.encoded));
} else if (lastNodeKey.length != 0) {
// We're dealing with a shrinking extension node.
// We need to modify the node to decrease the size of the key.
TrieNode memory modifiedLastNode = _makeExtensionNode(lastNodeKey, _getNodeValue(lastNode));
newBranch = _editBranchIndex(newBranch, branchKey, _getNodeHash(modifiedLastNode.encoded));
} else {
// We're dealing with an unnecessary extension node.
// We're going to delete the node entirely.
// Simply insert its current value into the branch index.
newBranch = _editBranchIndex(newBranch, branchKey, _getNodeValue(lastNode));
}
}
if (keyRemainder.length == 0) {
// We've got nothing left in the key remainder.
// Simply insert the value into the branch value slot.
newBranch = _editBranchValue(newBranch, _value);
// Push the branch into the list of new nodes.
newNodes[totalNewNodes] = newBranch;
totalNewNodes += 1;
} else {
// We've got some key remainder to work with.
// We'll be inserting a leaf node into the trie.
// First, move on to the next nibble.
keyRemainder = Lib_ByteUtils.slice(keyRemainder, 1);
// Push the branch into the list of new nodes.
newNodes[totalNewNodes] = newBranch;
totalNewNodes += 1;
// Push a new leaf node for our k/v pair.
newNodes[totalNewNodes] = _makeLeafNode(keyRemainder, _value);
totalNewNodes += 1;
}
}
// Finally, join the old path with our newly created nodes.
// Since we're overwriting the last node in the path, we use `_pathLength - 1`.
return _joinNodeArrays(_path, _pathLength - 1, newNodes, totalNewNodes);
}
/**
* @notice Computes the trie root from a given path.
* @param _nodes Path to some k/v pair.
* @param _key Key for the k/v pair.
* @return Root hash for the updated trie.
*/
function _getUpdatedTrieRoot(
TrieNode[] memory _nodes,
bytes memory _key
)
private
view
returns (
bytes32
)
{
bytes memory key = Lib_ByteUtils.toNibbles(_key);
// Some variables to keep track of during iteration.
TrieNode memory currentNode;
NodeType currentNodeType;
bytes memory previousNodeHash;
// Run through the path backwards to rebuild our root hash.
for (uint256 i = _nodes.length; i > 0; i--) {
// Pick out the current node.
currentNode = _nodes[i - 1];
currentNodeType = _getNodeType(currentNode);
if (currentNodeType == NodeType.LeafNode) {
// Leaf nodes are already correctly encoded.
// Shift the key over to account for the nodes key.
bytes memory nodeKey = _getNodeKey(currentNode);
key = Lib_ByteUtils.slice(key, 0, key.length - nodeKey.length);
} else if (currentNodeType == NodeType.ExtensionNode) {
// Shift the key over to account for the nodes key.
bytes memory nodeKey = _getNodeKey(currentNode);
key = Lib_ByteUtils.slice(key, 0, key.length - nodeKey.length);
// If this node is the last element in the path, it'll be correctly encoded
// and we can skip this part.
if (previousNodeHash.length > 0) {
// Re-encode the node based on the previous node.
currentNode = _makeExtensionNode(nodeKey, previousNodeHash);
}
} else if (currentNodeType == NodeType.BranchNode) {
// If this node is the last element in the path, it'll be correctly encoded
// and we can skip this part.
if (previousNodeHash.length > 0) {
// Re-encode the node based on the previous node.
uint8 branchKey = uint8(key[key.length - 1]);
key = Lib_ByteUtils.slice(key, 0, key.length - 1);
currentNode = _editBranchIndex(currentNode, branchKey, previousNodeHash);
}
}
// Compute the node hash for the next iteration.
previousNodeHash = _getNodeHash(currentNode.encoded);
}
// Current node should be the root at this point.
// Simply return the hash of its encoding.
return keccak256(currentNode.encoded);
}
/**
* @notice Parses an RLP-encoded proof into something more useful.
* @param _proof RLP-encoded proof to parse.
* @return Proof parsed into easily accessible structs.
*/
function _parseProof(
bytes memory _proof
)
private
view
returns (
TrieNode[] memory
)
{
Lib_RLPReader.RLPItem[] memory nodes = Lib_RLPReader.toList(Lib_RLPReader.toRlpItem(_proof));
TrieNode[] memory proof = new TrieNode[](nodes.length);
for (uint256 i = 0; i < nodes.length; i++) {
bytes memory encoded = Lib_RLPReader.toBytes(nodes[i]);
proof[i] = TrieNode({
encoded: encoded,
decoded: Lib_RLPReader.toList(Lib_RLPReader.toRlpItem(encoded))
});
}
return proof;
}
/**
* @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 for the node, depending on the size of its contents.
*/
function _getNodeID(
Lib_RLPReader.RLPItem memory _node
)
private
view
returns (
bytes32
)
{
bytes memory nodeID;
if (_node.len < 32) {
// Nodes smaller than 32 bytes are RLP encoded.
nodeID = Lib_RLPReader.toRlpBytes(_node);
} else {
// Nodes 32 bytes or larger are hashed.
nodeID = Lib_RLPReader.toBytes(_node);
}
return Lib_ByteUtils.toBytes32(nodeID);
}
/**
* @notice Gets the path for a leaf or extension node.
* @param _node Node to get a path for.
* @return Node path, converted to an array of nibbles.
*/
function _getNodePath(
TrieNode memory _node
)
private
view
returns (
bytes memory
)
{
return Lib_ByteUtils.toNibbles(Lib_RLPReader.toBytes(_node.decoded[0]));
}
/**
* @notice Gets the key for a leaf or extension node. Keys are essentially
* just paths without any prefix.
* @param _node Node to get a key for.
* @return Node key, converted to an array of nibbles.
*/
function _getNodeKey(
TrieNode memory _node
)
private
view
returns (
bytes memory
)
{
return _removeHexPrefix(_getNodePath(_node));
}
/**
* @notice Gets the path for a node.
* @param _node Node to get a value for.
* @return Node value, as hex bytes.
*/
function _getNodeValue(
TrieNode memory _node
)
private
view
returns (
bytes memory
)
{
return Lib_RLPReader.toBytes(_node.decoded[_node.decoded.length - 1]);
}
/**
* @notice Computes the node hash for an encoded node. Nodes < 32 bytes
* are not hashed, all others are keccak256 hashed.
* @param _encoded Encoded node to hash.
* @return Hash of the encoded node. Simply the input if < 32 bytes.
*/
function _getNodeHash(
bytes memory _encoded
)
private
pure
returns (
bytes memory
)
{
if (_encoded.length < 32) {
return _encoded;
} else {
return abi.encodePacked(keccak256(_encoded));
}
}
/**
* @notice Determines the type for a given node.
* @param _node Node to determine a type for.
* @return Type of the node; BranchNode/ExtensionNode/LeafNode.
*/
function _getNodeType(
TrieNode memory _node
)
private
view
returns (
NodeType
)
{
if (_node.decoded.length == BRANCH_NODE_LENGTH) {
return NodeType.BranchNode;
} else if (_node.decoded.length == LEAF_OR_EXTENSION_NODE_LENGTH) {
bytes memory path = _getNodePath(_node);
uint8 prefix = uint8(path[0]);
if (prefix == PREFIX_LEAF_EVEN || prefix == PREFIX_LEAF_ODD) {
return NodeType.LeafNode;
} else if (prefix == PREFIX_EXTENSION_EVEN || prefix == PREFIX_EXTENSION_ODD) {
return NodeType.ExtensionNode;
}
}
revert("Invalid node type");
}
/**
* @notice Utility; determines the number of nibbles shared between two
* nibble arrays.
* @param _a First nibble array.
* @param _b Second nibble array.
* @return Number of shared nibbles.
*/
function _getSharedNibbleLength(
bytes memory _a,
bytes memory _b
)
private
view
returns (
uint256
)
{
uint256 i = 0;
while (_a.length > i && _b.length > i && _a[i] == _b[i]) {
i++;
}
return i;
}
/**
* @notice Utility; converts an RLP-encoded node into our nice struct.
* @param _raw RLP-encoded node to convert.
* @return Node as a TrieNode struct.
*/
function _makeNode(
bytes[] memory _raw
)
private
view
returns (
TrieNode memory
)
{
bytes memory encoded = Lib_RLPWriter.encodeList(_raw);
return TrieNode({
encoded: encoded,
decoded: Lib_RLPReader.toList(Lib_RLPReader.toRlpItem(encoded))
});
}
/**
* @notice Utility; converts an RLP-decoded node into our nice struct.
* @param _items RLP-decoded node to convert.
* @return Node as a TrieNode struct.
*/
function _makeNode(
Lib_RLPReader.RLPItem[] memory _items
)
private
view
returns (
TrieNode memory
)
{
bytes[] memory raw = new bytes[](_items.length);
for (uint256 i = 0; i < _items.length; i++) {
raw[i] = Lib_RLPReader.toRlpBytes(_items[i]);
}
return _makeNode(raw);
}
/**
* @notice Creates a new extension node.
* @param _key Key for the extension node, unprefixed.
* @param _value Value for the extension node.
* @return New extension node with the given k/v pair.
*/
function _makeExtensionNode(
bytes memory _key,
bytes memory _value
)
private
view
returns (
TrieNode memory
)
{
bytes[] memory raw = new bytes[](2);
bytes memory key = _addHexPrefix(_key, false);
raw[0] = Lib_RLPWriter.encodeBytes(Lib_ByteUtils.fromNibbles(key));
raw[1] = Lib_RLPWriter.encodeBytes(_value);
return _makeNode(raw);
}
/**
* @notice Creates a new leaf node.
* @dev This function is essentially identical to `_makeExtensionNode`.
* Although we could route both to a single method with a flag, it's
* more gas efficient to keep them separate and duplicate the logic.
* @param _key Key for the leaf node, unprefixed.
* @param _value Value for the leaf node.
* @return New leaf node with the given k/v pair.
*/
function _makeLeafNode(
bytes memory _key,
bytes memory _value
)
private
view
returns (
TrieNode memory
)
{
bytes[] memory raw = new bytes[](2);
bytes memory key = _addHexPrefix(_key, true);
raw[0] = Lib_RLPWriter.encodeBytes(Lib_ByteUtils.fromNibbles(key));
raw[1] = Lib_RLPWriter.encodeBytes(_value);
return _makeNode(raw);
}
/**
* @notice Creates an empty branch node.
* @return Empty branch node as a TrieNode stuct.
*/
function _makeEmptyBranchNode()
private
view
returns (
TrieNode memory
)
{
bytes[] memory raw = new bytes[](BRANCH_NODE_LENGTH);
for (uint256 i = 0; i < raw.length; i++) {
raw[i] = RLP_NULL_BYTES;
}
return _makeNode(raw);
}
/**
* @notice Modifies the value slot for a given branch.
* @param _branch Branch node to modify.
* @param _value Value to insert into the branch.
* @return Modified branch node.
*/
function _editBranchValue(
TrieNode memory _branch,
bytes memory _value
)
private
view
returns (
TrieNode memory
)
{
bytes memory encoded = Lib_RLPWriter.encodeBytes(_value);
_branch.decoded[_branch.decoded.length - 1] = Lib_RLPReader.toRlpItem(encoded);
return _makeNode(_branch.decoded);
}
/**
* @notice Modifies a slot at an index for a given branch.
* @param _branch Branch node to modify.
* @param _index Slot index to modify.
* @param _value Value to insert into the slot.
* @return Modified branch node.
*/
function _editBranchIndex(
TrieNode memory _branch,
uint8 _index,
bytes memory _value
)
private
view
returns (
TrieNode memory
)
{
bytes memory encoded = _value.length < 32 ? _value : Lib_RLPWriter.encodeBytes(_value);
_branch.decoded[_index] = Lib_RLPReader.toRlpItem(encoded);
return _makeNode(_branch.decoded);
}
/**
* @notice Utility; adds a prefix to a key.
* @param _key Key to prefix.
* @param _isLeaf Whether or not the key belongs to a leaf.
* @return Prefixed key.
*/
function _addHexPrefix(
bytes memory _key,
bool _isLeaf
)
private
view
returns (
bytes memory
)
{
uint8 prefix = _isLeaf ? uint8(0x02) : uint8(0x00);
uint8 offset = uint8(_key.length % 2);
bytes memory prefixed = new bytes(2 - offset);
prefixed[0] = bytes1(prefix + offset);
return Lib_ByteUtils.concat(prefixed, _key);
}
/**
* @notice Utility; removes a prefix from a path.
* @param _path Path to remove the prefix from.
* @return Unprefixed key.
*/
function _removeHexPrefix(
bytes memory _path
)
private
view
returns (
bytes memory
)
{
if (uint8(_path[0]) % 2 == 0) {
return Lib_ByteUtils.slice(_path, 2);
} else {
return Lib_ByteUtils.slice(_path, 1);
}
}
/**
* @notice Utility; combines two node arrays. Array lengths are required
* because the actual lengths may be longer than the filled lengths.
* Array resizing is extremely costly and should be avoided.
* @param _a First array to join.
* @param _aLength Length of the first array.
* @param _b Second array to join.
* @param _bLength Length of the second array.
* @return Combined node array.
*/
function _joinNodeArrays(
TrieNode[] memory _a,
uint256 _aLength,
TrieNode[] memory _b,
uint256 _bLength
)
private
pure
returns (
TrieNode[] memory
)
{
TrieNode[] memory ret = new TrieNode[](_aLength + _bLength);
// Copy elements from the first array.
for (uint256 i = 0; i < _aLength; i++) {
ret[i] = _a[i];
}
// Copy elements from the second array.
for (uint256 i = 0; i < _bLength; i++) {
ret[i + _aLength] = _b[i];
}
return ret;
}
}
packages/contracts/build/contracts/libraries/trie/Lib_SecureMerkleTrie.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_MerkleTrie } from "./Lib_MerkleTrie.sol";
/**
* @title Lib_SecureMerkleTrie
*/
library Lib_SecureMerkleTrie {
/**********************
* Internal Functions *
**********************/
/**
* @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 `true` if the k/v pair exists in the trie, `false` otherwise.
*/
function verifyInclusionProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
internal
view
returns (
bool
)
{
bytes memory key = _getSecureKey(_key);
return Lib_MerkleTrie.verifyInclusionProof(key, _value, _proof, _root);
}
/**
* @notice Verifies a proof that a given key/value pair is *not* 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 node *nearest* the
* target node. We effectively need to show that either the key exists and
* its value differs, or the key does not exist at all.
* @param _root Known root of the Merkle trie. Used to verify that the
* included proof is correctly constructed.
* @return `true` if the k/v pair is absent in the trie, `false` otherwise.
*/
function verifyExclusionProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
internal
view
returns (
bool
)
{
bytes memory key = _getSecureKey(_key);
return Lib_MerkleTrie.verifyExclusionProof(key, _value, _proof, _root);
}
/**
* @notice Updates a Merkle trie and returns a new root hash.
* @param _key Key of the node to update, as a hex string.
* @param _value Value of the node to update, as a hex string.
* @param _proof Merkle trie inclusion proof for the node *nearest* the
* target node. If the key exists, we can simply update the value.
* Otherwise, we need to modify the trie to handle the new k/v pair.
* @param _root Known root of the Merkle trie. Used to verify that the
* included proof is correctly constructed.
* @return Root hash of the newly constructed trie.
*/
function update(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
internal
view
returns (
bytes32
)
{
bytes memory key = _getSecureKey(_key);
return Lib_MerkleTrie.update(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 Whether the node exists, value associated with the key if so.
*/
function get(
bytes memory _key,
bytes memory _proof,
bytes32 _root
)
internal
view
returns (
bool,
bytes memory
)
{
bytes memory key = _getSecureKey(_key);
return Lib_MerkleTrie.get(key, _proof, _root);
}
/**
* Computes the root hash for a trie with a single node.
* @param _key Key for the single node.
* @param _value Value for the single node.
* @return Hash of the trie.
*/
function getSingleNodeRootHash(
bytes memory _key,
bytes memory _value
)
internal
view
returns (
bytes32
)
{
bytes memory key = _getSecureKey(_key);
return Lib_MerkleTrie.getSingleNodeRootHash(key, _value);
}
/*********************
* Private Functions *
*********************/
function _getSecureKey(
bytes memory _key
)
private
pure
returns (
bytes memory
)
{
return abi.encodePacked(keccak256(_key));
}
}
\ No newline at end of file
packages/contracts/build/contracts/libraries/utils/Lib_ByteUtils.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/**
* @title Lib_ByteUtils
*/
library Lib_ByteUtils {
/**********************
* Internal Functions *
**********************/
function concat(
bytes memory _preBytes,
bytes memory _postBytes
)
internal
pure
returns (bytes memory)
{
bytes memory tempBytes;
assembly {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// Store the length of the first bytes array at the beginning of
// the memory for tempBytes.
let length := mload(_preBytes)
mstore(tempBytes, length)
// Maintain a memory counter for the current write location in the
// temp bytes array by adding the 32 bytes for the array length to
// the starting location.
let mc := add(tempBytes, 0x20)
// Stop copying when the memory counter reaches the length of the
// first bytes array.
let end := add(mc, length)
for {
// Initialize a copy counter to the start of the _preBytes data,
// 32 bytes into its memory.
let cc := add(_preBytes, 0x20)
} lt(mc, end) {
// Increase both counters by 32 bytes each iteration.
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// Write the _preBytes data into the tempBytes memory 32 bytes
// at a time.
mstore(mc, mload(cc))
}
// Add the length of _postBytes to the current length of tempBytes
// and store it as the new length in the first 32 bytes of the
// tempBytes memory.
length := mload(_postBytes)
mstore(tempBytes, add(length, mload(tempBytes)))
// Move the memory counter back from a multiple of 0x20 to the
// actual end of the _preBytes data.
mc := end
// Stop copying when the memory counter reaches the new combined
// length of the arrays.
end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
// Update the free-memory pointer by padding our last write location
// to 32 bytes: add 31 bytes to the end of tempBytes to move to the
// next 32 byte block, then round down to the nearest multiple of
// 32. If the sum of the length of the two arrays is zero then add
// one before rounding down to leave a blank 32 bytes (the length block with 0).
mstore(0x40, and(
add(add(end, iszero(add(length, mload(_preBytes)))), 31),
not(31) // Round down to the nearest 32 bytes.
))
}
return tempBytes;
}
function slice(
bytes memory _bytes,
uint256 _start,
uint256 _length
)
internal
pure
returns (bytes memory)
{
require(_bytes.length >= (_start + _length), "Read out of bounds");
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)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
function slice(
bytes memory _bytes,
uint256 _start
)
internal
pure
returns (bytes memory)
{
if (_bytes.length - _start == 0) {
return bytes('');
}
return slice(_bytes, _start, _bytes.length - _start);
}
function toBytes32(
bytes memory _bytes
)
internal
pure
returns (bytes32)
{
bytes32 ret;
assembly {
ret := mload(add(_bytes, 32))
}
return ret;
}
function toUint256(
bytes memory _bytes
)
internal
pure
returns (uint256)
{
return uint256(toBytes32(_bytes));
}
function toNibbles(
bytes memory _bytes
)
internal
pure
returns (bytes memory)
{
bytes memory nibbles = new bytes(_bytes.length * 2);
for (uint256 i = 0; i < _bytes.length; i++) {
nibbles[i * 2] = _bytes[i] >> 4;
nibbles[i * 2 + 1] = bytes1(uint8(_bytes[i]) % 16);
}
return nibbles;
}
function fromNibbles(
bytes memory _bytes
)
internal
pure
returns (bytes memory)
{
bytes memory ret = new bytes(_bytes.length / 2);
for (uint256 i = 0; i < ret.length; i++) {
ret[i] = (_bytes[i * 2] << 4) | (_bytes[i * 2 + 1]);
}
return ret;
}
function equal(
bytes memory _bytes,
bytes memory _other
)
internal
pure
returns (bool)
{
return keccak256(_bytes) == keccak256(_other);
}
}
packages/contracts/build/contracts/libraries/utils/Lib_ECDSAUtils.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/**
* @title Lib_ECDSAUtils
*/
library Lib_ECDSAUtils {
/**************************************
* Internal Functions: ECDSA Recovery *
**************************************/
/**
* Recovers a signed address given a message and signature.
* @param _message Message that was originally signed.
* @param _isEthSignedMessage Whether or not the user used the `Ethereum Signed Message` prefix.
* @param _v Signature `v` parameter.
* @param _r Signature `r` parameter.
* @param _s Signature `s` parameter.
* @param _chainId Chain ID parameter.
* @return _sender Signer address.
*/
function recover(
bytes memory _message,
bool _isEthSignedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint256 _chainId
)
internal
pure
returns (
address _sender
)
{
bytes32 messageHash;
if (_isEthSignedMessage) {
messageHash = getEthSignedMessageHash(_message);
} else {
messageHash = getNativeMessageHash(_message);
}
return ecrecover(
messageHash,
(_v - uint8(_chainId) * 2) - 8,
_r,
_s
);
}
/*************************************
* Private Functions: ECDSA Recovery *
*************************************/
/**
* Gets the native message hash (simple keccak256) for a message.
* @param _message Message to hash.
* @return _messageHash Native message hash.
*/
function getNativeMessageHash(
bytes memory _message
)
private
pure
returns (
bytes32 _messageHash
)
{
return keccak256(_message);
}
/**
* Gets the hash of a message with the `Ethereum Signed Message` prefix.
* @param _message Message to hash.
* @return _messageHash Prefixed message hash.
*/
function getEthSignedMessageHash(
bytes memory _message
)
private
pure
returns (
bytes32 _messageHash
)
{
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 messageHash = keccak256(_message);
return keccak256(abi.encodePacked(prefix, messageHash));
}
}
\ No newline at end of file
packages/contracts/build/contracts/libraries/utils/Lib_EthUtils.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol";
/**
* @title Lib_EthUtils
*/
library Lib_EthUtils {
/***********************************
* Internal Functions: Code Access *
***********************************/
/**
* Gets the code for a given address.
* @param _address Address to get code for.
* @param _offset Offset to start reading from.
* @param _length Number of bytes to read.
* @return _code Code read from the contract.
*/
function getCode(
address _address,
uint256 _offset,
uint256 _length
)
internal
view
returns (
bytes memory _code
)
{
assembly {
_code := mload(0x40)
mstore(0x40, add(_code, add(_length, 0x20)))
mstore(_code, _length)
extcodecopy(_address, add(_code, 0x20), _offset, _length)
}
return _code;
}
/**
* Gets the full code for a given address.
* @param _address Address to get code for.
* @return _code Full code of the contract.
*/
function getCode(
address _address
)
internal
view
returns (
bytes memory _code
)
{
return getCode(
_address,
0,
getCodeSize(_address)
);
}
/**
* Gets the size of a contract's code in bytes.
* @param _address Address to get code size for.
* @return _codeSize Size of the contract's code in bytes.
*/
function getCodeSize(
address _address
)
internal
view
returns (
uint256 _codeSize
)
{
assembly {
_codeSize := extcodesize(_address)
}
return _codeSize;
}
/**
* Gets the hash of a contract's code.
* @param _address Address to get a code hash for.
* @return _codeHash Hash of the contract's code.
*/
function getCodeHash(
address _address
)
internal
view
returns (
bytes32 _codeHash
)
{
assembly {
_codeHash := extcodehash(_address)
}
return _codeHash;
}
/*****************************************
* Internal Functions: Contract Creation *
*****************************************/
/**
* Creates a contract with some given initialization code.
* @param _code Contract initialization code.
* @return _created Address of the created contract.
*/
function createContract(
bytes memory _code
)
internal
returns (
address _created
)
{
assembly {
_created := create(
0,
add(_code, 0x20),
mload(_code)
)
}
return _created;
}
/**
* Computes the address that would be generated by CREATE.
* @param _creator Address creating the contract.
* @param _nonce Creator's nonce.
* @return _address Address to be generated by CREATE.
*/
function getAddressForCREATE(
address _creator,
uint256 _nonce
)
internal
view
returns (
address _address
)
{
bytes[] memory encoded = new bytes[](2);
encoded[0] = Lib_RLPWriter.encodeAddress(_creator);
encoded[1] = Lib_RLPWriter.encodeUint(_nonce);
bytes memory encodedList = Lib_RLPWriter.encodeList(encoded);
return getAddressFromHash(keccak256(encodedList));
}
/**
* Computes the address that would be generated by CREATE2.
* @param _creator Address creating the contract.
* @param _bytecode Bytecode of the contract to be created.
* @param _salt 32 byte salt value mixed into the hash.
* @return _address Address to be generated by CREATE2.
*/
function getAddressForCREATE2(
address _creator,
bytes memory _bytecode,
bytes32 _salt
)
internal
view
returns (address _address)
{
bytes32 hashedData = keccak256(abi.encodePacked(
byte(0xff),
_creator,
_salt,
keccak256(_bytecode)
));
return getAddressFromHash(hashedData);
}
/****************************************
* Private Functions: Contract Creation *
****************************************/
/**
* Determines an address from a 32 byte hash. Since addresses are only
* 20 bytes, we need to retrieve the last 20 bytes from the original
* hash. Converting to uint256 and then uint160 gives us these bytes.
* @param _hash Hash to convert to an address.
* @return _address Hash converted to an address.
*/
function getAddressFromHash(
bytes32 _hash
)
private
pure
returns (
address _address
)
{
return address(bytes20(uint160(uint256(_hash))));
}
}
packages/contracts/build/contracts/libraries/utils/Lib_MerkleUtils.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/**
* @title Lib_MerkleUtils
*/
library Lib_MerkleUtils {
function getMerkleRoot(
bytes32[] memory _hashes
)
internal
view
returns (
bytes32 _root
)
{
if (_hashes.length == 1) {
return _hashes[0];
}
bytes32[] memory defaultHashes = _getDefaultHashes(_hashes.length);
bytes32[] memory nodes = _hashes;
if (_hashes.length % 2 == 1) {
nodes = new bytes32[](_hashes.length + 1);
for (uint256 i = 0; i < _hashes.length; i++) {
nodes[i] = _hashes[i];
}
}
uint256 currentLevel = 0;
uint256 nextLevelSize = _hashes.length;
if (nextLevelSize % 2 == 1) {
nodes[nextLevelSize] = defaultHashes[currentLevel];
nextLevelSize += 1;
}
while (nextLevelSize > 1) {
currentLevel += 1;
for (uint256 i = 0; i < nextLevelSize / 2; i++) {
nodes[i] = _getParentHash(
nodes[i*2],
nodes[i*2 + 1]
);
}
nextLevelSize = nextLevelSize / 2;
if (nextLevelSize % 2 == 1 && nextLevelSize != 1) {
nodes[nextLevelSize] = defaultHashes[currentLevel];
nextLevelSize += 1;
}
}
return nodes[0];
}
function getMerkleRoot(
bytes[] memory _elements
)
internal
view
returns (
bytes32 _root
)
{
bytes32[] memory hashes = new bytes32[](_elements.length);
for (uint256 i = 0; i < _elements.length; i++) {
hashes[i] = keccak256(_elements[i]);
}
return getMerkleRoot(hashes);
}
function verify(
bytes32 _root,
bytes memory _leaf,
uint256 _path,
bytes32[] memory _siblings
)
internal
pure
returns (
bool _verified
)
{
bytes32 computedRoot = keccak256(_leaf);
for (uint256 i = 0; i < _siblings.length; i++) {
bytes32 sibling = _siblings[i];
bool isRightSibling = uint8(_path >> i & 1) == 1;
if (isRightSibling) {
computedRoot = _getParentHash(computedRoot, sibling);
} else {
computedRoot = _getParentHash(sibling, computedRoot);
}
}
return computedRoot == _root;
}
function _getDefaultHashes(
uint256 _length
)
private
pure
returns (
bytes32[] memory _defaultHashes
)
{
bytes32[] memory defaultHashes = new bytes32[](_length);
defaultHashes[0] = keccak256(abi.encodePacked(uint256(0)));
for (uint256 i = 1; i < defaultHashes.length; i++) {
defaultHashes[i] = keccak256(abi.encodePacked(defaultHashes[i-1]));
}
return defaultHashes;
}
function _getParentHash(
bytes32 _leftChildHash,
bytes32 _rightChildHash
)
private
pure
returns (
bytes32 _hash
)
{
return keccak256(abi.encodePacked(_leftChildHash, _rightChildHash));
}
}
\ No newline at end of file
packages/contracts/build/contracts/mockOVM/bridge/mockOVM_CrossDomainMessenger.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Contract Imports */
import { OVM_BaseCrossDomainMessenger } from "../../OVM/bridge/OVM_BaseCrossDomainMessenger.sol";
/**
* @title mockOVM_CrossDomainMessenger
*/
contract mockOVM_CrossDomainMessenger is OVM_BaseCrossDomainMessenger {
/***********
* Structs *
***********/
struct ReceivedMessage {
uint256 timestamp;
address target;
address sender;
bytes message;
uint256 messageNonce;
uint256 gasLimit;
}
/**********************
* Contract Variables *
**********************/
ReceivedMessage[] internal fullReceivedMessages;
uint256 internal lastRelayedMessage;
uint256 internal delay;
/***************
* Constructor *
***************/
/**
* @param _delay Time in seconds before a message can be relayed.
*/
constructor(
uint256 _delay
) {
delay = _delay;
}
/********************
* Public Functions *
********************/
/**
* Sends a message to another mock xdomain messenger.
* @param _target Target for the message.
* @param _message Message to send.
* @param _gasLimit Amount of gas to send with the call.
*/
function sendMessage(
address _target,
bytes memory _message,
uint32 _gasLimit
)
public
{
mockOVM_CrossDomainMessenger targetMessenger = mockOVM_CrossDomainMessenger(
targetMessengerAddress
);
// Just send it over!
targetMessenger.receiveMessage(ReceivedMessage({
timestamp: block.timestamp,
target: _target,
sender: msg.sender,
message: _message,
messageNonce: messageNonce,
gasLimit: _gasLimit
}));
messageNonce += 1;
}
/**
* Receives a message to be sent later.
* @param _message Message to send later.
*/
function receiveMessage(
ReceivedMessage memory _message
)
public
{
fullReceivedMessages.push(_message);
}
/**
* Checks whether we have messages to relay.
* @param _exists Whether or not we have more messages to relay.
*/
function hasNextMessage()
public
view
returns (
bool _exists
)
{
return fullReceivedMessages.length < lastRelayedMessage;
}
/**
* Relays the last received message not yet relayed.
*/
function relayNextMessage()
public
{
if (hasNextMessage() == false) {
return;
}
ReceivedMessage memory nextMessage = fullReceivedMessages[lastRelayedMessage];
if (nextMessage.timestamp + delay > block.timestamp) {
return;
}
xDomainMessageSender = nextMessage.sender;
nextMessage.target.call{gas: nextMessage.gasLimit}(nextMessage.message);
lastRelayedMessage += 1;
}
}
packages/contracts/build/contracts/proxy/Proxy_Forwarder.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Proxy Imports */
import { Proxy_Manager } from "./Proxy_Manager.sol";
/**
* @title Proxy_Forwarder
*/
contract Proxy_Forwarder {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
Proxy_Manager private proxyManager;
/***************
* Constructor *
***************/
/**
* @param _proxyManager Address of the Proxy_Manager.
*/
constructor(
address _proxyManager
) {
proxyManager = Proxy_Manager(_proxyManager);
}
/********************
* Public Functions *
********************/
/**
* Forwards calls to the appropriate target.
*/
fallback()
external
{
address target = _getTarget();
require(
target != address(0),
"Proxy does not have a target."
);
(bool success, bytes memory returndata) = target.call(msg.data);
if (success == true) {
assembly {
return(add(returndata, 0x20), mload(returndata))
}
} else {
assembly {
revert(add(returndata, 0x20), mload(returndata))
}
}
}
/**********************
* Internal Functions *
**********************/
/**
* Determines the appropriate target.
* @return _target Target to forward requests to.
*/
function _getTarget()
internal
view
returns (
address _target
)
{
address target;
if (proxyManager.isProxy(msg.sender)) {
target = proxyManager.getTarget(msg.sender);
} else if (proxyManager.hasProxy(msg.sender)) {
target = proxyManager.getProxy(msg.sender);
} else {
target = proxyManager.getTarget(address(this));
}
return target;
}
}
packages/contracts/build/contracts/proxy/Proxy_Manager.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/**
* @title Proxy_Manager
*/
contract Proxy_Manager {
/*******************************************
* Contract Variables: Internal Accounting *
*******************************************/
mapping (bytes32 => address) private proxyByName;
mapping (bytes32 => address) private targetByName;
mapping (address => bytes32) private nameByProxy;
mapping (address => bytes32) private nameByTarget;
/********************
* Public Functions *
********************/
function setProxy(
string memory _name,
address _proxy
)
public
{
proxyByName[_getNameHash(_name)] = _proxy;
nameByProxy[_proxy] = _getNameHash(_name);
}
function getProxy(
string memory _name
)
public
view
returns (
address _proxy
)
{
return proxyByName[_getNameHash(_name)];
}
function getProxy(
address _target
)
public
view
returns (
address _proxy
)
{
return proxyByName[nameByTarget[_target]];
}
function hasProxy(
string memory _name
)
public
view
returns (
bool _hasProxy
)
{
return getProxy(_name) != address(0);
}
function hasProxy(
address _target
)
public
view
returns (
bool _hasProxy
)
{
return getProxy(_target) != address(0);
}
function isProxy(
address _proxy
)
public
view
returns (
bool _isProxy
)
{
return nameByProxy[_proxy] != bytes32('');
}
function setTarget(
string memory _name,
address _target
)
public
{
targetByName[_getNameHash(_name)] = _target;
nameByTarget[_target] = _getNameHash(_name);
}
function getTarget(
string memory _name
)
public
view
returns (
address _target
)
{
return targetByName[_getNameHash(_name)];
}
function getTarget(
address _proxy
)
public
view
returns (
address _target
)
{
return targetByName[nameByProxy[_proxy]];
}
function hasTarget(
string memory _name
)
public
view
returns (
bool _hasTarget
)
{
return getTarget(_name) != address(0);
}
function hasTarget(
address _proxy
)
public
view
returns (
bool _hasTarget
)
{
return getTarget(_proxy) != address(0);
}
function isTarget(
address _target
)
public
view
returns (
bool _isTarget
)
{
return nameByTarget[_target] != bytes32('');
}
/**********************
* Internal Functions *
**********************/
function _getNameHash(
string memory _name
)
internal
pure
returns (
bytes32 _hash
)
{
return keccak256(abi.encodePacked(_name));
}
}
packages/contracts/build/contracts/proxy/Proxy_Resolver.sol deleted 100644 → 0
View file @ 6e1dbfe0
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Proxy Imports */
import { Proxy_Manager } from "./Proxy_Manager.sol";
/**
* @title Proxy_Resolver
*/
contract Proxy_Resolver {
/*******************************************
* Contract Variables: Contract References *
*******************************************/
Proxy_Manager internal proxyManager;
/***************
* Constructor *
***************/
/**
* @param _proxyManager Address of the Proxy_Manager.
*/
constructor(
address _proxyManager
) {
proxyManager = Proxy_Manager(_proxyManager);
}
/********************
* Public Functions *
********************/
function resolve(
string memory _name
)
public
view
returns (
address _proxy
)
{
return proxyManager.getProxy(_name);
}
function resolveTarget(
string memory _name
)
public
view
returns (
address _target
)
{
return proxyManager.getTarget(_name);
}
}
packages/contracts/build/test/helpers/buidler/modify-compiler.js deleted 100644 → 0
View file @ 6e1dbfe0
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs_extra_1 = __importDefault(require("fs-extra"));
const config_1 = require("@nomiclabs/buidler/config");
const strings_1 = require("@nomiclabs/buidler/internal/util/strings");
const artifacts_1 = require("@nomiclabs/buidler/internal/artifacts");
const task_names_1 = require("@nomiclabs/buidler/builtin-tasks/task-names");
config_1.internalTask(task_names_1.TASK_COMPILE_GET_COMPILER_INPUT, async (_, { config, run }, runSuper) => {
const input = await runSuper();
input.settings.outputSelection['*']['*'].push('storageLayout');
return input;
});
config_1.internalTask(task_names_1.TASK_BUILD_ARTIFACTS).setAction(async ({ force }, { config, run }) => {
const sources = await run(task_names_1.TASK_COMPILE_GET_SOURCE_PATHS);
if (sources.length === 0) {
console.log('No Solidity source file available.');
return;
}
const isCached = await run(task_names_1.TASK_COMPILE_CHECK_CACHE, { force });
if (isCached) {
console.log('All contracts have already been compiled, skipping compilation.');
return;
}
const compilationOutput = await run(task_names_1.TASK_COMPILE_COMPILE);
if (compilationOutput === undefined) {
return;
}
await fs_extra_1.default.ensureDir(config.paths.artifacts);
let numberOfContracts = 0;
for (const file of Object.values(compilationOutput.contracts)) {
for (const [contractName, contractOutput] of Object.entries(file)) {
const artifact = artifacts_1.getArtifactFromContractOutput(contractName, contractOutput);
numberOfContracts += 1;
artifact.storageLayout = contractOutput.storageLayout;
await artifacts_1.saveArtifact(config.paths.artifacts, artifact);
}
}
console.log('Compiled', numberOfContracts, strings_1.pluralize(numberOfContracts, 'contract'), 'successfully');
});
//# sourceMappingURL=modify-compiler.js.map
\ No newline at end of file
packages/contracts/build/test/helpers/buidler/modify-compiler.js.map deleted 100644 → 0
View file @ 6e1dbfe0
{"version":3,"file":"modify-compiler.js","sourceRoot":"","sources":["../../../../test/helpers/buidler/modify-compiler.ts"],"names":[],"mappings":";;;;;AACA,wDAA8B;AAC9B,sDAAwD;AACxD,sEAAoE;AACpE,qEAG8C;AAC9C,4EAMoD;AAEpD,qBAAY,CACV,4CAA+B,EAC/B,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,EAAE;IACrC,MAAM,KAAK,GAAG,MAAM,QAAQ,EAAE,CAAA;IAG9B,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;IAE9D,OAAO,KAAK,CAAA;AACd,CAAC,CACF,CAAA;AAED,qBAAY,CAAC,iCAAoB,CAAC,CAAC,SAAS,CAC1C,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE;IACnC,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,0CAA6B,CAAC,CAAA;IAExD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;QACxB,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAA;QACjD,OAAM;KACP;IAED,MAAM,QAAQ,GAAY,MAAM,GAAG,CAAC,qCAAwB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAA;IAExE,IAAI,QAAQ,EAAE;QACZ,OAAO,CAAC,GAAG,CACT,iEAAiE,CAClE,CAAA;QACD,OAAM;KACP;IAED,MAAM,iBAAiB,GAAG,MAAM,GAAG,CAAC,iCAAoB,CAAC,CAAA;IAEzD,IAAI,iBAAiB,KAAK,SAAS,EAAE;QACnC,OAAM;KACP;IAED,MAAM,kBAAO,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;IAC/C,IAAI,iBAAiB,GAAG,CAAC,CAAA;IAEzB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAM,iBAAiB,CAAC,SAAS,CAAC,EAAE;QAClE,KAAK,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACjE,MAAM,QAAQ,GAAQ,yCAA6B,CACjD,YAAY,EACZ,cAAc,CACf,CAAA;YACD,iBAAiB,IAAI,CAAC,CAAA;YAGtB,QAAQ,CAAC,aAAa,GAAI,cAAsB,CAAC,aAAa,CAAA;YAE9D,MAAM,wBAAY,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;SACrD;KACF;IAED,OAAO,CAAC,GAAG,CACT,UAAU,EACV,iBAAiB,EACjB,mBAAS,CAAC,iBAAiB,EAAE,UAAU,CAAC,EACxC,cAAc,CACf,CAAA;AACH,CAAC,CACF,CAAA"}
\ No newline at end of file
packages/contracts/build/test/helpers/constants.d.ts deleted 100644 → 0
View file @ 6e1dbfe0
export declare const DEFAULT_ACCOUNTS: {
balance: string;
secretKey: string;
}[];
export declare const DEFAULT_ACCOUNTS_BUIDLER: {
balance: string;
privateKey: string;
}[];
export declare const OVM_TX_GAS_LIMIT = 10000000;
export declare const RUN_OVM_TEST_GAS = 20000000;
export declare const FORCE_INCLUSION_PERIOD_SECONDS = 600;
export declare const NULL_BYTES32: string;
export declare const NON_NULL_BYTES32: string;
export declare const ZERO_ADDRESS: string;
export declare const NON_ZERO_ADDRESS: string;
export declare const VERIFIED_EMPTY_CONTRACT_HASH = "0x00004B1DC0DE000000004B1DC0DE000000004B1DC0DE000000004B1DC0DE0000";
export declare const NUISANCE_GAS_COSTS: {
NUISANCE_GAS_SLOAD: number;
NUISANCE_GAS_SSTORE: number;
MIN_NUISANCE_GAS_PER_CONTRACT: number;
NUISANCE_GAS_PER_CONTRACT_BYTE: number;
MIN_GAS_FOR_INVALID_STATE_ACCESS: number;
};
export declare const Helper_TestRunner_BYTELEN = 3654;
export declare const STORAGE_XOR = "0xfeedfacecafebeeffeedfacecafebeeffeedfacecafebeeffeedfacecafebeef";
export declare const getStorageXOR: (key: string) => string;
packages/contracts/build/test/helpers/constants.js deleted 100644 → 0
View file @ 6e1dbfe0
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getStorageXOR = exports.STORAGE_XOR = exports.Helper_TestRunner_BYTELEN = exports.NUISANCE_GAS_COSTS = exports.VERIFIED_EMPTY_CONTRACT_HASH = exports.NON_ZERO_ADDRESS = exports.ZERO_ADDRESS = exports.NON_NULL_BYTES32 = exports.NULL_BYTES32 = exports.FORCE_INCLUSION_PERIOD_SECONDS = exports.RUN_OVM_TEST_GAS = exports.OVM_TX_GAS_LIMIT = exports.DEFAULT_ACCOUNTS_BUIDLER = exports.DEFAULT_ACCOUNTS = void 0;
const ethers_1 = require("ethers");
const ethereum_waffle_1 = require("ethereum-waffle");
const buffer_xor_1 = __importDefault(require("buffer-xor"));
const utils_1 = require("./utils");
exports.DEFAULT_ACCOUNTS = ethereum_waffle_1.defaultAccounts;
exports.DEFAULT_ACCOUNTS_BUIDLER = ethereum_waffle_1.defaultAccounts.map((account) => {
return {
balance: ethers_1.ethers.BigNumber.from(account.balance).toHexString(),
privateKey: account.secretKey,
};
});
exports.OVM_TX_GAS_LIMIT = 10000000;
exports.RUN_OVM_TEST_GAS = 20000000;
exports.FORCE_INCLUSION_PERIOD_SECONDS = 600;
exports.NULL_BYTES32 = utils_1.makeHexString('00', 32);
exports.NON_NULL_BYTES32 = utils_1.makeHexString('11', 32);
exports.ZERO_ADDRESS = utils_1.makeAddress('00');
exports.NON_ZERO_ADDRESS = utils_1.makeAddress('11');
exports.VERIFIED_EMPTY_CONTRACT_HASH = '0x00004B1DC0DE000000004B1DC0DE000000004B1DC0DE000000004B1DC0DE0000';
exports.NUISANCE_GAS_COSTS = {
NUISANCE_GAS_SLOAD: 20000,
NUISANCE_GAS_SSTORE: 20000,
MIN_NUISANCE_GAS_PER_CONTRACT: 30000,
NUISANCE_GAS_PER_CONTRACT_BYTE: 100,
MIN_GAS_FOR_INVALID_STATE_ACCESS: 30000,
};
exports.Helper_TestRunner_BYTELEN = 3654;
exports.STORAGE_XOR = '0xfeedfacecafebeeffeedfacecafebeeffeedfacecafebeeffeedfacecafebeef';
exports.getStorageXOR = (key) => {
return utils_1.toHexString(buffer_xor_1.default(utils_1.fromHexString(key), utils_1.fromHexString(exports.STORAGE_XOR)));
};
//# sourceMappingURL=constants.js.map
\ No newline at end of file
packages/contracts/build/test/helpers/constants.js.map deleted 100644 → 0
View file @ 6e1dbfe0
{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../test/helpers/constants.ts"],"names":[],"mappings":";;;;;;AACA,mCAA+B;AAC/B,qDAAiD;AACjD,4DAA4B;AAG5B,mCAAgF;AAEnE,QAAA,gBAAgB,GAAG,iCAAe,CAAA;AAClC,QAAA,wBAAwB,GAAG,iCAAe,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;IACtE,OAAO;QACL,OAAO,EAAE,eAAM,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE;QAC7D,UAAU,EAAE,OAAO,CAAC,SAAS;KAC9B,CAAA;AACH,CAAC,CAAC,CAAA;AAEW,QAAA,gBAAgB,GAAG,QAAU,CAAA;AAC7B,QAAA,gBAAgB,GAAG,QAAU,CAAA;AAC7B,QAAA,8BAA8B,GAAG,GAAG,CAAA;AAEpC,QAAA,YAAY,GAAG,qBAAa,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;AACtC,QAAA,gBAAgB,GAAG,qBAAa,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;AAC1C,QAAA,YAAY,GAAG,mBAAW,CAAC,IAAI,CAAC,CAAA;AAChC,QAAA,gBAAgB,GAAG,mBAAW,CAAC,IAAI,CAAC,CAAA;AAEpC,QAAA,4BAA4B,GACvC,oEAAoE,CAAA;AAEzD,QAAA,kBAAkB,GAAG;IAChC,kBAAkB,EAAE,KAAK;IACzB,mBAAmB,EAAE,KAAK;IAC1B,6BAA6B,EAAE,KAAK;IACpC,8BAA8B,EAAE,GAAG;IACnC,gCAAgC,EAAE,KAAK;CACxC,CAAA;AAGY,QAAA,yBAAyB,GAAG,IAAI,CAAA;AAEhC,QAAA,WAAW,GAAG,oEAAoE,CAAA;AAClF,QAAA,aAAa,GAAG,CAAC,GAAW,EAAU,EAAE;IACnD,OAAO,mBAAW,CAAC,oBAAG,CAAC,qBAAa,CAAC,GAAG,CAAC,EAAE,qBAAa,CAAC,mBAAW,CAAC,CAAC,CAAC,CAAA;AACzE,CAAC,CAAA"}
\ No newline at end of file
packages/contracts/build/test/helpers/utils/buffer-utils.d.ts deleted 100644 → 0
View file @ 6e1dbfe0
/// <reference types="node" />
export declare const toHexString: (buf: Buffer | string) => string;
export declare const fromHexString: (str: string | Buffer) => Buffer;
packages/contracts/build/test/helpers/utils/buffer-utils.js deleted 100644 → 0
View file @ 6e1dbfe0
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.fromHexString = exports.toHexString = void 0;
exports.toHexString = (buf) => {
return '0x' + exports.fromHexString(buf).toString('hex');
};
exports.fromHexString = (str) => {
if (typeof str === 'string' && str.startsWith('0x')) {
return Buffer.from(str.slice(2), 'hex');
}
return Buffer.from(str);
};
//# sourceMappingURL=buffer-utils.js.map
\ No newline at end of file
packages/contracts/build/test/helpers/utils/buffer-utils.js.map deleted 100644 → 0
View file @ 6e1dbfe0
{"version":3,"file":"buffer-utils.js","sourceRoot":"","sources":["../../../../test/helpers/utils/buffer-utils.ts"],"names":[],"mappings":";;;AAKa,QAAA,WAAW,GAAG,CAAC,GAAoB,EAAU,EAAE;IAC1D,OAAO,IAAI,GAAG,qBAAa,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;AAClD,CAAC,CAAA;AAOY,QAAA,aAAa,GAAG,CAAC,GAAoB,EAAU,EAAE;IAC5D,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;QACnD,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;KACxC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACzB,CAAC,CAAA"}
\ No newline at end of file
packages/contracts/build/test/helpers/utils/byte-utils.d.ts deleted 100644 → 0
View file @ 6e1dbfe0
export declare const makeHexString: (byte: string, len: number) => string;
export declare const makeAddress: (byte: string) => string;
export declare const remove0x: (str: string) => string;
packages/contracts/build/test/helpers/utils/byte-utils.js deleted 100644 → 0
View file @ 6e1dbfe0
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.remove0x = exports.makeAddress = exports.makeHexString = void 0;
exports.makeHexString = (byte, len) => {
return '0x' + byte.repeat(len);
};
exports.makeAddress = (byte) => {
return exports.makeHexString(byte, 20);
};
exports.remove0x = (str) => {
if (str.startsWith('0x')) {
return str.slice(2);
}
else {
return str;
}
};
//# sourceMappingURL=byte-utils.js.map
\ No newline at end of file
packages/contracts/build/test/helpers/utils/byte-utils.js.map deleted 100644 → 0
View file @ 6e1dbfe0
{"version":3,"file":"byte-utils.js","sourceRoot":"","sources":["../../../../test/helpers/utils/byte-utils.ts"],"names":[],"mappings":";;;AAMa,QAAA,aAAa,GAAG,CAAC,IAAY,EAAE,GAAW,EAAU,EAAE;IACjE,OAAO,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AAChC,CAAC,CAAA;AAOY,QAAA,WAAW,GAAG,CAAC,IAAY,EAAU,EAAE;IAClD,OAAO,qBAAa,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;AAChC,CAAC,CAAA;AAOY,QAAA,QAAQ,GAAG,CAAC,GAAW,EAAU,EAAE;IAC9C,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;QACxB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;KACpB;SAAM;QACL,OAAO,GAAG,CAAA;KACX;AACH,CAAC,CAAA"}
\ No newline at end of file
packages/contracts/build/test/helpers/utils/index.d.ts deleted 100644 → 0
View file @ 6e1dbfe0
export * from './buffer-utils';
export * from './byte-utils';
packages/contracts/build/test/helpers/utils/index.js deleted 100644 → 0
View file @ 6e1dbfe0
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
__exportStar(require("./buffer-utils"), exports);
__exportStar(require("./byte-utils"), exports);
//# sourceMappingURL=index.js.map
\ No newline at end of file
packages/contracts/build/test/helpers/utils/index.js.map deleted 100644 → 0
View file @ 6e1dbfe0
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../test/helpers/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,iDAA8B;AAC9B,+CAA4B"}
\ No newline at end of file
packages/contracts/contracts/optimistic-ethereum/OVM/bridge/OVM_L1CrossDomainMessenger.sol
View file @ c7b37b40
...@@ -5,7 +5,7 @@ pragma experimental ABIEncoderV2; ...@@ -5,7 +5,7 @@ pragma experimental ABIEncoderV2;
/* Library Imports */ /* Library Imports */
import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol"; import { Lib_AddressResolver } from "../../libraries/resolver/Lib_AddressResolver.sol";
import { Lib_EthMerkleTrie } from "../../libraries/trie/Lib_EthMerkleTrie.sol"; import { Lib_EthMerkleTrie } from "../../libraries/trie/Lib_EthMerkleTrie.sol";
import { Lib_ByteUtils } from "../../libraries/utils/Lib_ByteUtils.sol"; import { Lib_BytesUtils } from "../../libraries/utils/Lib_BytesUtils.sol";
/* Interface Imports */ /* Interface Imports */
import { iOVM_L1CrossDomainMessenger } from "../../iOVM/bridge/iOVM_L1CrossDomainMessenger.sol"; import { iOVM_L1CrossDomainMessenger } from "../../iOVM/bridge/iOVM_L1CrossDomainMessenger.sol";
...@@ -215,7 +215,7 @@ contract OVM_L1CrossDomainMessenger is iOVM_L1CrossDomainMessenger, OVM_BaseCros ...@@ -215,7 +215,7 @@ contract OVM_L1CrossDomainMessenger is iOVM_L1CrossDomainMessenger, OVM_BaseCros
) )
{ {
bytes32 storageKey = keccak256( bytes32 storageKey = keccak256(
Lib_ByteUtils.concat( Lib_BytesUtils.concat(
abi.encodePacked(keccak256(_xDomainCalldata)), abi.encodePacked(keccak256(_xDomainCalldata)),
abi.encodePacked(uint256(0)) abi.encodePacked(uint256(0))
) )
......
packages/contracts/contracts/optimistic-ethereum/OVM/execution/OVM_StateManager.sol
View file @ c7b37b40
...@@ -25,8 +25,8 @@ contract OVM_StateManager is iOVM_StateManager { ...@@ -25,8 +25,8 @@ contract OVM_StateManager is iOVM_StateManager {
* Contract Variables: Contract References * * Contract Variables: Contract References *
*******************************************/ *******************************************/
address internal owner; address public owner;
address internal ovmExecutionManager; address public ovmExecutionManager;
/**************************************** /****************************************
......
packages/contracts/contracts/optimistic-ethereum/libraries/rlp/Lib_RLPReader.sol
View file @ c7b37b40
...@@ -27,7 +27,6 @@ library Lib_RLPReader { ...@@ -27,7 +27,6 @@ library Lib_RLPReader {
uint8 constant private LIST_LONG_START = 0xf8; uint8 constant private LIST_LONG_START = 0xf8;
uint8 constant private WORD_SIZE = 32; uint8 constant private WORD_SIZE = 32;
/* /*
* Public Functions * Public Functions
*/ */
......
packages/contracts/contracts/optimistic-ethereum/libraries/rlp/Lib_RLPWriter.sol
View file @ c7b37b40
...@@ -2,175 +2,198 @@ ...@@ -2,175 +2,198 @@
pragma solidity ^0.7.0; pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2; pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_BytesUtils } from "../utils/Lib_BytesUtils.sol";
/** /**
* Source: https://github.com/omisego/plasma-mvp/blob/master/plasma/root_chain/contracts/RLPEncode.sol * @title Lib_RLPWriter
* @title RLPEncode * @author Bakaoh (with modifications)
* @dev A simple RLP encoding library.
* @author Bakaoh
*/ */
library Lib_RLPWriter { library Lib_RLPWriter {
/*
* Public Functions /**********************
*/ * Internal Functions *
**********************/
/** /**
* RLP encodes a byte string. * RLP encodes a byte string.
* @param self The byte string to encode. * @param _in The byte string to encode.
* @return The RLP encoded string in bytes. * @return _out The RLP encoded string in bytes.
*/ */
function encodeBytes( function encodeBytes(
bytes memory self bytes memory _in
) )
internal internal
pure pure
returns (bytes memory) returns (
bytes memory _out
)
{ {
bytes memory encoded; bytes memory encoded;
if (self.length == 1 && uint8(self[0]) < 128) {
encoded = self; if (_in.length == 1 && uint8(_in[0]) < 128) {
encoded = _in;
} else { } else {
encoded = concat(encodeLength(self.length, 128), self); encoded = Lib_BytesUtils.concat(encodeLength(_in.length, 128), _in);
} }
return encoded; return encoded;
} }
/** /**
* RLP encodes a list of RLP encoded byte byte strings. * RLP encodes a list of RLP encoded byte byte strings.
* @param self The list of RLP encoded byte strings. * @param _in The list of RLP encoded byte strings.
* @return The RLP encoded list of items in bytes. * @return _out The RLP encoded list of items in bytes.
*/ */
function encodeList( function encodeList(
bytes[] memory self bytes[] memory _in
) )
internal internal
pure pure
returns (bytes memory) returns (
bytes memory _out
)
{ {
bytes memory list = flatten(self); bytes memory list = flatten(_in);
return concat(encodeLength(list.length, 192), list); return Lib_BytesUtils.concat(encodeLength(list.length, 192), list);
} }
/** /**
* RLP encodes a string. * RLP encodes a string.
* @param self The string to encode. * @param _in The string to encode.
* @return The RLP encoded string in bytes. * @return _out The RLP encoded string in bytes.
*/ */
function encodeString( function encodeString(
string memory self string memory _in
) )
internal internal
pure pure
returns (bytes memory) returns (
bytes memory _out
)
{ {
return encodeBytes(bytes(self)); return encodeBytes(bytes(_in));
} }
/** /**
* RLP encodes an address. * RLP encodes an address.
* @param self The address to encode. * @param _in The address to encode.
* @return The RLP encoded address in bytes. * @return _out The RLP encoded address in bytes.
*/ */
function encodeAddress( function encodeAddress(
address self address _in
) )
internal internal
pure pure
returns (bytes memory) returns (
bytes memory _out
)
{ {
bytes memory inputBytes; bytes memory inputBytes;
assembly { assembly {
let m := mload(0x40) let m := mload(0x40)
mstore(add(m, 20), xor(0x140000000000000000000000000000000000000000, self)) mstore(add(m, 20), xor(0x140000000000000000000000000000000000000000, _in))
mstore(0x40, add(m, 52)) mstore(0x40, add(m, 52))
inputBytes := m inputBytes := m
} }
return encodeBytes(inputBytes); return encodeBytes(inputBytes);
} }
/** /**
* RLP encodes a uint. * RLP encodes a uint.
* @param self The uint to encode. * @param _in The uint to encode.
* @return The RLP encoded uint in bytes. * @return _out The RLP encoded uint in bytes.
*/ */
function encodeUint( function encodeUint(
uint self uint _in
) )
internal internal
pure pure
returns (bytes memory) returns (
bytes memory _out
)
{ {
return encodeBytes(toBinary(self)); return encodeBytes(toBinary(_in));
} }
/** /**
* RLP encodes an int. * RLP encodes an int.
* @param self The int to encode. * @param _in The int to encode.
* @return The RLP encoded int in bytes. * @return _out The RLP encoded int in bytes.
*/ */
function encodeInt( function encodeInt(
int self int _in
) )
internal internal
pure pure
returns (bytes memory) returns (
bytes memory _out
)
{ {
return encodeUint(uint(self)); return encodeUint(uint(_in));
} }
/** /**
* RLP encodes a bool. * RLP encodes a bool.
* @param self The bool to encode. * @param _in The bool to encode.
* @return The RLP encoded bool in bytes. * @return _out The RLP encoded bool in bytes.
*/ */
function encodeBool( function encodeBool(
bool self bool _in
) )
internal internal
pure pure
returns (bytes memory) returns (
bytes memory _out
)
{ {
bytes memory encoded = new bytes(1); bytes memory encoded = new bytes(1);
encoded[0] = (self ? bytes1(0x01) : bytes1(0x80)); encoded[0] = (_in ? bytes1(0x01) : bytes1(0x80));
return encoded; return encoded;
} }
/* /*********************
* Private Functions * Private Functions *
*/ *********************/
/** /**
* Encode the first byte, followed by the `len` in binary form if `length` is more than 55. * Encode the first byte, followed by the `len` in binary form if `length` is more than 55.
* @param len The length of the string or the payload. * @param _len The length of the string or the payload.
* @param offset 128 if item is string, 192 if item is list. * @param _offset 128 if item is string, 192 if item is list.
* @return RLP encoded bytes. * @return _encoded RLP encoded bytes.
*/ */
function encodeLength( function encodeLength(
uint len, uint _len,
uint offset uint _offset
) )
private private
pure pure
returns (bytes memory) returns (
bytes memory _encoded
)
{ {
bytes memory encoded; bytes memory encoded;
if (len < 56) {
if (_len < 56) {
encoded = new bytes(1); encoded = new bytes(1);
encoded[0] = byte(uint8(len) + uint8(offset)); encoded[0] = byte(uint8(_len) + uint8(_offset));
} else { } else {
uint lenLen; uint lenLen;
uint i = 1; uint i = 1;
while (len / i != 0) { while (_len / i != 0) {
lenLen++; lenLen++;
i *= 256; i *= 256;
} }
encoded = new bytes(lenLen + 1); encoded = new bytes(lenLen + 1);
encoded[0] = byte(uint8(lenLen) + uint8(offset) + 55); encoded[0] = byte(uint8(lenLen) + uint8(_offset) + 55);
for(i = 1; i <= lenLen; i++) { for(i = 1; i <= lenLen; i++) {
encoded[i] = byte(uint8((len / (256**(lenLen-i))) % 256)); encoded[i] = byte(uint8((_len / (256**(lenLen-i))) % 256));
} }
} }
return encoded; return encoded;
} }
...@@ -178,29 +201,34 @@ library Lib_RLPWriter { ...@@ -178,29 +201,34 @@ library Lib_RLPWriter {
* Encode integer in big endian binary form with no leading zeroes. * Encode integer in big endian binary form with no leading zeroes.
* @notice TODO: This should be optimized with assembly to save gas costs. * @notice TODO: This should be optimized with assembly to save gas costs.
* @param _x The integer to encode. * @param _x The integer to encode.
* @return RLP encoded bytes. * @return _binary RLP encoded bytes.
*/ */
function toBinary( function toBinary(
uint _x uint _x
) )
private private
pure pure
returns (bytes memory) returns (
bytes memory _binary
)
{ {
bytes memory b = new bytes(32); bytes memory b = new bytes(32);
assembly { assembly {
mstore(add(b, 32), _x) mstore(add(b, 32), _x)
} }
uint i = 0; uint i = 0;
for (; i < 32; i++) { for (; i < 32; i++) {
if (b[i] != 0) { if (b[i] != 0) {
break; break;
} }
} }
bytes memory res = new bytes(32 - i); bytes memory res = new bytes(32 - i);
for (uint j = 0; j < res.length; j++) { for (uint j = 0; j < res.length; j++) {
res[j] = b[i++]; res[j] = b[i++];
} }
return res; return res;
} }
...@@ -243,14 +271,16 @@ library Lib_RLPWriter { ...@@ -243,14 +271,16 @@ library Lib_RLPWriter {
* Flattens a list of byte strings into one byte string. * Flattens a list of byte strings into one byte string.
* @notice From: https://github.com/sammayo/solidity-rlp-encoder/blob/master/RLPEncode.sol. * @notice From: https://github.com/sammayo/solidity-rlp-encoder/blob/master/RLPEncode.sol.
* @param _list List of byte strings to flatten. * @param _list List of byte strings to flatten.
* @return The flattened byte string. * @return _flattened The flattened byte string.
*/ */
function flatten( function flatten(
bytes[] memory _list bytes[] memory _list
) )
private private
pure pure
returns (bytes memory) returns (
bytes memory _flattened
)
{ {
if (_list.length == 0) { if (_list.length == 0) {
return new bytes(0); return new bytes(0);
...@@ -278,63 +308,4 @@ library Lib_RLPWriter { ...@@ -278,63 +308,4 @@ library Lib_RLPWriter {
return flattened; return flattened;
} }
/**
* Concatenates two bytes.
* @notice From: https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol.
* @param _preBytes First byte string.
* @param _postBytes Second byte string.
* @return Both byte string combined.
*/
function concat(
bytes memory _preBytes,
bytes memory _postBytes
)
private
pure
returns (bytes memory)
{
bytes memory tempBytes;
assembly {
tempBytes := mload(0x40)
let length := mload(_preBytes)
mstore(tempBytes, length)
let mc := add(tempBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_preBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
length := mload(_postBytes)
mstore(tempBytes, add(length, mload(tempBytes)))
mc := end
end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(0x40, and(
add(add(end, iszero(add(length, mload(_preBytes)))), 31),
not(31)
))
}
return tempBytes;
}
} }
packages/contracts/contracts/optimistic-ethereum/libraries/trie/Lib_EthMerkleTrie.sol
View file @ c7b37b40
...@@ -5,7 +5,7 @@ pragma experimental ABIEncoderV2; ...@@ -5,7 +5,7 @@ pragma experimental ABIEncoderV2;
/* Library Imports */ /* Library Imports */
import { Lib_SecureMerkleTrie } from "./Lib_SecureMerkleTrie.sol"; import { Lib_SecureMerkleTrie } from "./Lib_SecureMerkleTrie.sol";
import { Lib_OVMCodec } from "../codec/Lib_OVMCodec.sol"; import { Lib_OVMCodec } from "../codec/Lib_OVMCodec.sol";
import { Lib_ByteUtils } from "../utils/Lib_ByteUtils.sol"; import { Lib_BytesUtils } from "../utils/Lib_BytesUtils.sol";
import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol"; import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol";
import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol"; import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol";
...@@ -685,8 +685,8 @@ library Lib_EthMerkleTrie { ...@@ -685,8 +685,8 @@ library Lib_EthMerkleTrie {
return Lib_OVMCodec.EVMAccount({ return Lib_OVMCodec.EVMAccount({
nonce: Lib_RLPReader.toUint(accountState[0]), nonce: Lib_RLPReader.toUint(accountState[0]),
balance: Lib_RLPReader.toUint(accountState[1]), balance: Lib_RLPReader.toUint(accountState[1]),
storageRoot: Lib_ByteUtils.toBytes32(Lib_RLPReader.toBytes(accountState[2])), storageRoot: Lib_BytesUtils.toBytes32(Lib_RLPReader.toBytes(accountState[2])),
codeHash: Lib_ByteUtils.toBytes32(Lib_RLPReader.toBytes(accountState[3])) codeHash: Lib_BytesUtils.toBytes32(Lib_RLPReader.toBytes(accountState[3]))
}); });
} }
......
packages/contracts/contracts/optimistic-ethereum/libraries/trie/Lib_MerkleTrie.sol
View file @ c7b37b40
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
pragma solidity ^0.7.0; pragma solidity ^0.7.0;
/* Library Imports */ /* Library Imports */
import { Lib_ByteUtils } from "../utils/Lib_ByteUtils.sol"; import { Lib_BytesUtils } from "../utils/Lib_BytesUtils.sol";
import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol"; import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol";
import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol"; import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol";
...@@ -234,13 +234,13 @@ library Lib_MerkleTrie { ...@@ -234,13 +234,13 @@ library Lib_MerkleTrie {
// Included leaf nodes should have no key remainder, values should match. // Included leaf nodes should have no key remainder, values should match.
return ( return (
keyRemainder.length == 0 && keyRemainder.length == 0 &&
Lib_ByteUtils.equal(_getNodeValue(proof[pathLength - 1]), _value) Lib_BytesUtils.equal(_getNodeValue(proof[pathLength - 1]), _value)
); );
} else { } else {
// If there's no key remainder then a leaf with the given key exists and the value should differ. // If there's no key remainder then a leaf with the given key exists and the value should differ.
// Otherwise, we need to make sure that we've hit a dead end. // Otherwise, we need to make sure that we've hit a dead end.
return ( return (
(keyRemainder.length == 0 && !Lib_ByteUtils.equal(_getNodeValue(proof[pathLength - 1]), _value)) || (keyRemainder.length == 0 && !Lib_BytesUtils.equal(_getNodeValue(proof[pathLength - 1]), _value)) ||
(keyRemainder.length != 0 && isFinalNode) (keyRemainder.length != 0 && isFinalNode)
); );
} }
...@@ -271,7 +271,7 @@ library Lib_MerkleTrie { ...@@ -271,7 +271,7 @@ library Lib_MerkleTrie {
) )
{ {
uint256 pathLength = 0; uint256 pathLength = 0;
bytes memory key = Lib_ByteUtils.toNibbles(_key); bytes memory key = Lib_BytesUtils.toNibbles(_key);
bytes32 currentNodeID = _root; bytes32 currentNodeID = _root;
uint256 currentKeyIndex = 0; uint256 currentKeyIndex = 0;
...@@ -302,7 +302,7 @@ library Lib_MerkleTrie { ...@@ -302,7 +302,7 @@ library Lib_MerkleTrie {
} else { } else {
// Nodes smaller than 31 bytes aren't hashed. // Nodes smaller than 31 bytes aren't hashed.
require( require(
Lib_ByteUtils.toBytes32(currentNode.encoded) == currentNodeID, Lib_BytesUtils.toBytes32(currentNode.encoded) == currentNodeID,
"Invalid internal node hash" "Invalid internal node hash"
); );
} }
...@@ -324,8 +324,8 @@ library Lib_MerkleTrie { ...@@ -324,8 +324,8 @@ library Lib_MerkleTrie {
bytes memory path = _getNodePath(currentNode); bytes memory path = _getNodePath(currentNode);
uint8 prefix = uint8(path[0]); uint8 prefix = uint8(path[0]);
uint8 offset = 2 - prefix % 2; uint8 offset = 2 - prefix % 2;
bytes memory pathRemainder = Lib_ByteUtils.slice(path, offset); bytes memory pathRemainder = Lib_BytesUtils.slice(path, offset);
bytes memory keyRemainder = Lib_ByteUtils.slice(key, currentKeyIndex); bytes memory keyRemainder = Lib_BytesUtils.slice(key, currentKeyIndex);
uint256 sharedNibbleLength = _getSharedNibbleLength(pathRemainder, keyRemainder); uint256 sharedNibbleLength = _getSharedNibbleLength(pathRemainder, keyRemainder);
if (prefix == PREFIX_LEAF_EVEN || prefix == PREFIX_LEAF_ODD) { if (prefix == PREFIX_LEAF_EVEN || prefix == PREFIX_LEAF_ODD) {
...@@ -360,7 +360,7 @@ library Lib_MerkleTrie { ...@@ -360,7 +360,7 @@ library Lib_MerkleTrie {
// If our node ID is NULL, then we're at a dead end. // If our node ID is NULL, then we're at a dead end.
bool isFinalNode = currentNodeID == bytes32(RLP_NULL); bool isFinalNode = currentNodeID == bytes32(RLP_NULL);
return (pathLength, Lib_ByteUtils.slice(key, currentKeyIndex), isFinalNode); return (pathLength, Lib_BytesUtils.slice(key, currentKeyIndex), isFinalNode);
} }
/** /**
...@@ -418,7 +418,7 @@ library Lib_MerkleTrie { ...@@ -418,7 +418,7 @@ library Lib_MerkleTrie {
totalNewNodes += 1; totalNewNodes += 1;
// Create a new leaf node, slicing our remainder since the first byte points // Create a new leaf node, slicing our remainder since the first byte points
// to our branch node. // to our branch node.
newNodes[totalNewNodes] = _makeLeafNode(Lib_ByteUtils.slice(keyRemainder, 1), _value); newNodes[totalNewNodes] = _makeLeafNode(Lib_BytesUtils.slice(keyRemainder, 1), _value);
totalNewNodes += 1; totalNewNodes += 1;
} }
} else { } else {
...@@ -429,13 +429,13 @@ library Lib_MerkleTrie { ...@@ -429,13 +429,13 @@ library Lib_MerkleTrie {
if (sharedNibbleLength != 0) { if (sharedNibbleLength != 0) {
// We've got some shared nibbles between the last node and our key remainder. // We've got some shared nibbles between the last node and our key remainder.
// We'll need to insert an extension node that covers these shared nibbles. // We'll need to insert an extension node that covers these shared nibbles.
bytes memory nextNodeKey = Lib_ByteUtils.slice(lastNodeKey, 0, sharedNibbleLength); bytes memory nextNodeKey = Lib_BytesUtils.slice(lastNodeKey, 0, sharedNibbleLength);
newNodes[totalNewNodes] = _makeExtensionNode(nextNodeKey, _getNodeHash(_value)); newNodes[totalNewNodes] = _makeExtensionNode(nextNodeKey, _getNodeHash(_value));
totalNewNodes += 1; totalNewNodes += 1;
// Cut down the keys since we've just covered these shared nibbles. // Cut down the keys since we've just covered these shared nibbles.
lastNodeKey = Lib_ByteUtils.slice(lastNodeKey, sharedNibbleLength); lastNodeKey = Lib_BytesUtils.slice(lastNodeKey, sharedNibbleLength);
keyRemainder = Lib_ByteUtils.slice(keyRemainder, sharedNibbleLength); keyRemainder = Lib_BytesUtils.slice(keyRemainder, sharedNibbleLength);
} }
// Create an empty branch to fill in. // Create an empty branch to fill in.
...@@ -451,7 +451,7 @@ library Lib_MerkleTrie { ...@@ -451,7 +451,7 @@ library Lib_MerkleTrie {
// We're going to modify some index of our branch. // We're going to modify some index of our branch.
uint8 branchKey = uint8(lastNodeKey[0]); uint8 branchKey = uint8(lastNodeKey[0]);
// Move on to the next nibble. // Move on to the next nibble.
lastNodeKey = Lib_ByteUtils.slice(lastNodeKey, 1); lastNodeKey = Lib_BytesUtils.slice(lastNodeKey, 1);
if (lastNodeType == NodeType.LeafNode) { if (lastNodeType == NodeType.LeafNode) {
// We're dealing with a leaf node. // We're dealing with a leaf node.
...@@ -482,7 +482,7 @@ library Lib_MerkleTrie { ...@@ -482,7 +482,7 @@ library Lib_MerkleTrie {
// We've got some key remainder to work with. // We've got some key remainder to work with.
// We'll be inserting a leaf node into the trie. // We'll be inserting a leaf node into the trie.
// First, move on to the next nibble. // First, move on to the next nibble.
keyRemainder = Lib_ByteUtils.slice(keyRemainder, 1); keyRemainder = Lib_BytesUtils.slice(keyRemainder, 1);
// Push the branch into the list of new nodes. // Push the branch into the list of new nodes.
newNodes[totalNewNodes] = newBranch; newNodes[totalNewNodes] = newBranch;
totalNewNodes += 1; totalNewNodes += 1;
...@@ -513,7 +513,7 @@ library Lib_MerkleTrie { ...@@ -513,7 +513,7 @@ library Lib_MerkleTrie {
bytes32 bytes32
) )
{ {
bytes memory key = Lib_ByteUtils.toNibbles(_key); bytes memory key = Lib_BytesUtils.toNibbles(_key);
// Some variables to keep track of during iteration. // Some variables to keep track of during iteration.
TrieNode memory currentNode; TrieNode memory currentNode;
...@@ -530,11 +530,11 @@ library Lib_MerkleTrie { ...@@ -530,11 +530,11 @@ library Lib_MerkleTrie {
// Leaf nodes are already correctly encoded. // Leaf nodes are already correctly encoded.
// Shift the key over to account for the nodes key. // Shift the key over to account for the nodes key.
bytes memory nodeKey = _getNodeKey(currentNode); bytes memory nodeKey = _getNodeKey(currentNode);
key = Lib_ByteUtils.slice(key, 0, key.length - nodeKey.length); key = Lib_BytesUtils.slice(key, 0, key.length - nodeKey.length);
} else if (currentNodeType == NodeType.ExtensionNode) { } else if (currentNodeType == NodeType.ExtensionNode) {
// Shift the key over to account for the nodes key. // Shift the key over to account for the nodes key.
bytes memory nodeKey = _getNodeKey(currentNode); bytes memory nodeKey = _getNodeKey(currentNode);
key = Lib_ByteUtils.slice(key, 0, key.length - nodeKey.length); key = Lib_BytesUtils.slice(key, 0, key.length - nodeKey.length);
// If this node is the last element in the path, it'll be correctly encoded // If this node is the last element in the path, it'll be correctly encoded
// and we can skip this part. // and we can skip this part.
...@@ -548,7 +548,7 @@ library Lib_MerkleTrie { ...@@ -548,7 +548,7 @@ library Lib_MerkleTrie {
if (previousNodeHash.length > 0) { if (previousNodeHash.length > 0) {
// Re-encode the node based on the previous node. // Re-encode the node based on the previous node.
uint8 branchKey = uint8(key[key.length - 1]); uint8 branchKey = uint8(key[key.length - 1]);
key = Lib_ByteUtils.slice(key, 0, key.length - 1); key = Lib_BytesUtils.slice(key, 0, key.length - 1);
currentNode = _editBranchIndex(currentNode, branchKey, previousNodeHash); currentNode = _editBranchIndex(currentNode, branchKey, previousNodeHash);
} }
} }
...@@ -616,7 +616,7 @@ library Lib_MerkleTrie { ...@@ -616,7 +616,7 @@ library Lib_MerkleTrie {
nodeID = Lib_RLPReader.toBytes(_node); nodeID = Lib_RLPReader.toBytes(_node);
} }
return Lib_ByteUtils.toBytes32(nodeID); return Lib_BytesUtils.toBytes32(nodeID);
} }
/** /**
...@@ -633,7 +633,7 @@ library Lib_MerkleTrie { ...@@ -633,7 +633,7 @@ library Lib_MerkleTrie {
bytes memory bytes memory
) )
{ {
return Lib_ByteUtils.toNibbles(Lib_RLPReader.toBytes(_node.decoded[0])); return Lib_BytesUtils.toNibbles(Lib_RLPReader.toBytes(_node.decoded[0]));
} }
/** /**
...@@ -808,7 +808,7 @@ library Lib_MerkleTrie { ...@@ -808,7 +808,7 @@ library Lib_MerkleTrie {
{ {
bytes[] memory raw = new bytes[](2); bytes[] memory raw = new bytes[](2);
bytes memory key = _addHexPrefix(_key, false); bytes memory key = _addHexPrefix(_key, false);
raw[0] = Lib_RLPWriter.encodeBytes(Lib_ByteUtils.fromNibbles(key)); raw[0] = Lib_RLPWriter.encodeBytes(Lib_BytesUtils.fromNibbles(key));
raw[1] = Lib_RLPWriter.encodeBytes(_value); raw[1] = Lib_RLPWriter.encodeBytes(_value);
return _makeNode(raw); return _makeNode(raw);
} }
...@@ -834,7 +834,7 @@ library Lib_MerkleTrie { ...@@ -834,7 +834,7 @@ library Lib_MerkleTrie {
{ {
bytes[] memory raw = new bytes[](2); bytes[] memory raw = new bytes[](2);
bytes memory key = _addHexPrefix(_key, true); bytes memory key = _addHexPrefix(_key, true);
raw[0] = Lib_RLPWriter.encodeBytes(Lib_ByteUtils.fromNibbles(key)); raw[0] = Lib_RLPWriter.encodeBytes(Lib_BytesUtils.fromNibbles(key));
raw[1] = Lib_RLPWriter.encodeBytes(_value); raw[1] = Lib_RLPWriter.encodeBytes(_value);
return _makeNode(raw); return _makeNode(raw);
} }
...@@ -921,7 +921,7 @@ library Lib_MerkleTrie { ...@@ -921,7 +921,7 @@ library Lib_MerkleTrie {
uint8 offset = uint8(_key.length % 2); uint8 offset = uint8(_key.length % 2);
bytes memory prefixed = new bytes(2 - offset); bytes memory prefixed = new bytes(2 - offset);
prefixed[0] = bytes1(prefix + offset); prefixed[0] = bytes1(prefix + offset);
return Lib_ByteUtils.concat(prefixed, _key); return Lib_BytesUtils.concat(prefixed, _key);
} }
/** /**
...@@ -939,9 +939,9 @@ library Lib_MerkleTrie { ...@@ -939,9 +939,9 @@ library Lib_MerkleTrie {
) )
{ {
if (uint8(_path[0]) % 2 == 0) { if (uint8(_path[0]) % 2 == 0) {
return Lib_ByteUtils.slice(_path, 2); return Lib_BytesUtils.slice(_path, 2);
} else { } else {
return Lib_ByteUtils.slice(_path, 1); return Lib_BytesUtils.slice(_path, 1);
} }
} }
......
packages/contracts/contracts/optimistic-ethereum/libraries/utils/Lib_ByteUtils.sol → packages/contracts/contracts/optimistic-ethereum/libraries/utils/Lib_BytesUtils.sol
View file @ c7b37b40
...@@ -2,9 +2,9 @@ ...@@ -2,9 +2,9 @@
pragma solidity ^0.7.0; pragma solidity ^0.7.0;
/** /**
* @title Lib_ByteUtils * @title Lib_BytesUtils
*/ */
library Lib_ByteUtils { library Lib_BytesUtils {
/********************** /**********************
* Internal Functions * * Internal Functions *
......
packages/contracts/contracts/test-helpers/Helper_SimpleProxy.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
contract Helper_SimpleProxy {
address private target;
constructor(
address _target
) {
target = _target;
}
fallback()
external
{
(bool success, bytes memory returndata) = target.call(msg.data);
if (success) {
assembly {
return(add(returndata, 0x20), mload(returndata))
}
} else {
assembly {
revert(add(returndata, 0x20), mload(returndata))
}
}
}
}
packages/contracts/contracts/test-libraries/codec/TestLib_OVMCodec.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_OVMCodec } from "../../optimistic-ethereum/libraries/codec/Lib_OVMCodec.sol";
/**
* @title TestLib_OVMCodec
*/
library TestLib_OVMCodec {
function decodeEOATransaction(
bytes memory _transaction
)
public
pure
returns (
Lib_OVMCodec.EOATransaction memory _decoded
)
{
return Lib_OVMCodec.decodeEOATransaction(_transaction);
}
function encodeTransaction(
Lib_OVMCodec.Transaction memory _transaction
)
public
pure
returns (
bytes memory _encoded
)
{
return Lib_OVMCodec.encodeTransaction(_transaction);
}
function hashTransaction(
Lib_OVMCodec.Transaction memory _transaction
)
public
pure
returns (
bytes32 _hash
)
{
return Lib_OVMCodec.hashTransaction(_transaction);
}
}
packages/contracts/contracts/test-libraries/rlp/TestLib_RLPWriter.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_RLPWriter } from "../../optimistic-ethereum/libraries/rlp/Lib_RLPWriter.sol";
/**
* @title TestLib_RLPWriter
*/
library TestLib_RLPWriter {
function encodeBytes(
bytes memory _in
)
public
pure
returns (
bytes memory _out
)
{
return Lib_RLPWriter.encodeBytes(_in);
}
function encodeList(
bytes[] memory _in
)
public
pure
returns (
bytes memory _out
)
{
return Lib_RLPWriter.encodeList(_in);
}
function encodeString(
string memory _in
)
public
pure
returns (
bytes memory _out
)
{
return Lib_RLPWriter.encodeString(_in);
}
function encodeAddress(
address _in
)
public
pure
returns (
bytes memory _out
)
{
return Lib_RLPWriter.encodeAddress(_in);
}
function encodeUint(
uint _in
)
public
pure
returns (
bytes memory _out
)
{
return Lib_RLPWriter.encodeUint(_in);
}
function encodeInt(
int _in
)
public
pure
returns (
bytes memory _out
)
{
return Lib_RLPWriter.encodeInt(_in);
}
function encodeBool(
bool _in
)
public
pure
returns (
bytes memory _out
)
{
return Lib_RLPWriter.encodeBool(_in);
}
}
packages/contracts/contracts/test-libraries/trie/TestLib_EthMerkleTrie.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_EthMerkleTrie } from "../../optimistic-ethereum/libraries/trie/Lib_EthMerkleTrie.sol";
import { Lib_OVMCodec } from "../../optimistic-ethereum/libraries/codec/Lib_OVMCodec.sol";
/**
* @title TestLib_EthMerkleTrie
*/
library TestLib_EthMerkleTrie {
function proveAccountStorageSlotValue(
address _address,
bytes32 _key,
bytes32 _value,
bytes memory _stateTrieWitness,
bytes memory _storageTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bool)
{
return Lib_EthMerkleTrie.proveAccountStorageSlotValue(
_address,
_key,
_value,
_stateTrieWitness,
_storageTrieWitness,
_stateTrieRoot
);
}
function updateAccountStorageSlotValue(
address _address,
bytes32 _key,
bytes32 _value,
bytes memory _stateTrieWitness,
bytes memory _storageTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bytes32)
{
return Lib_EthMerkleTrie.updateAccountStorageSlotValue(
_address,
_key,
_value,
_stateTrieWitness,
_storageTrieWitness,
_stateTrieRoot
);
}
function proveAccountState(
address _address,
Lib_OVMCodec.EVMAccount memory _accountState,
Lib_OVMCodec.ProofMatrix memory _proofMatrix,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bool)
{
return Lib_EthMerkleTrie.proveAccountState(
_address,
_accountState,
_proofMatrix,
_stateTrieWitness,
_stateTrieRoot
);
}
function proveAccountState(
address _address,
Lib_OVMCodec.EVMAccount memory _accountState,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bool)
{
return Lib_EthMerkleTrie.proveAccountState(
_address,
_accountState,
_stateTrieWitness,
_stateTrieRoot
);
}
function proveAccountState(
address _address,
Lib_OVMCodec.Account memory _accountState,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bool)
{
return Lib_EthMerkleTrie.proveAccountState(
_address,
_accountState,
_stateTrieWitness,
_stateTrieRoot
);
}
function proveAccountNonce(
address _address,
uint256 _nonce,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bool)
{
return Lib_EthMerkleTrie.proveAccountNonce(
_address,
_nonce,
_stateTrieWitness,
_stateTrieRoot
);
}
function proveAccountBalance(
address _address,
uint256 _balance,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bool)
{
return Lib_EthMerkleTrie.proveAccountBalance(
_address,
_balance,
_stateTrieWitness,
_stateTrieRoot
);
}
function proveAccountStorageRoot(
address _address,
bytes32 _storageRoot,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bool)
{
return Lib_EthMerkleTrie.proveAccountStorageRoot(
_address,
_storageRoot,
_stateTrieWitness,
_stateTrieRoot
);
}
function proveAccountCodeHash(
address _address,
bytes32 _codeHash,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bool)
{
return Lib_EthMerkleTrie.proveAccountCodeHash(
_address,
_codeHash,
_stateTrieWitness,
_stateTrieRoot
);
}
function updateAccountState(
address _address,
Lib_OVMCodec.EVMAccount memory _accountState,
Lib_OVMCodec.ProofMatrix memory _proofMatrix,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bytes32)
{
return Lib_EthMerkleTrie.updateAccountState(
_address,
_accountState,
_proofMatrix,
_stateTrieWitness,
_stateTrieRoot
);
}
function updateAccountState(
address _address,
Lib_OVMCodec.EVMAccount memory _accountState,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bytes32)
{
return Lib_EthMerkleTrie.updateAccountState(
_address,
_accountState,
_stateTrieWitness,
_stateTrieRoot
);
}
function updateAccountState(
address _address,
Lib_OVMCodec.Account memory _accountState,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bytes32)
{
return Lib_EthMerkleTrie.updateAccountState(
_address,
_accountState,
_stateTrieWitness,
_stateTrieRoot
);
}
function updateAccountNonce(
address _address,
uint256 _nonce,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bytes32)
{
return Lib_EthMerkleTrie.updateAccountNonce(
_address,
_nonce,
_stateTrieWitness,
_stateTrieRoot
);
}
function updateAccountBalance(
address _address,
uint256 _balance,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bytes32)
{
return Lib_EthMerkleTrie.updateAccountBalance(
_address,
_balance,
_stateTrieWitness,
_stateTrieRoot
);
}
function updateAccountStorageRoot(
address _address,
bytes32 _storageRoot,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bytes32)
{
return Lib_EthMerkleTrie.updateAccountStorageRoot(
_address,
_storageRoot,
_stateTrieWitness,
_stateTrieRoot
);
}
function updateAccountCodeHash(
address _address,
bytes32 _codeHash,
bytes memory _stateTrieWitness,
bytes32 _stateTrieRoot
)
public
view
returns (bytes32)
{
return Lib_EthMerkleTrie.updateAccountCodeHash(
_address,
_codeHash,
_stateTrieWitness,
_stateTrieRoot
);
}
}
packages/contracts/contracts/test-libraries/trie/TestLib_MerkleTrie.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Library Imports */
import { Lib_MerkleTrie } from "../../optimistic-ethereum/libraries/trie/Lib_MerkleTrie.sol";
/**
* @title TestLib_MerkleTrie
*/
library TestLib_MerkleTrie {
function verifyInclusionProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
public
view
returns (
bool
)
{
return Lib_MerkleTrie.verifyInclusionProof(
_key,
_value,
_proof,
_root
);
}
function verifyExclusionProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
public
view
returns (
bool
)
{
return Lib_MerkleTrie.verifyExclusionProof(
_key,
_value,
_proof,
_root
);
}
function update(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
public
view
returns (
bytes32
)
{
return Lib_MerkleTrie.update(
_key,
_value,
_proof,
_root
);
}
function get(
bytes memory _key,
bytes memory _proof,
bytes32 _root
)
public
view
returns (
bool,
bytes memory
)
{
return Lib_MerkleTrie.get(
_key,
_proof,
_root
);
}
function getSingleNodeRootHash(
bytes memory _key,
bytes memory _value
)
public
view
returns (
bytes32
)
{
return Lib_MerkleTrie.getSingleNodeRootHash(
_key,
_value
);
}
}
packages/contracts/contracts/test-libraries/trie/TestLib_SecureMerkleTrie.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_SecureMerkleTrie } from "../../optimistic-ethereum/libraries/trie/Lib_SecureMerkleTrie.sol";
/**
* @title TestLib_SecureMerkleTrie
*/
library TestLib_SecureMerkleTrie {
function verifyInclusionProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
public
view
returns (
bool
)
{
return Lib_SecureMerkleTrie.verifyInclusionProof(
_key,
_value,
_proof,
_root
);
}
function verifyExclusionProof(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
public
view
returns (
bool
)
{
return Lib_SecureMerkleTrie.verifyExclusionProof(
_key,
_value,
_proof,
_root
);
}
function update(
bytes memory _key,
bytes memory _value,
bytes memory _proof,
bytes32 _root
)
public
view
returns (
bytes32
)
{
return Lib_SecureMerkleTrie.update(
_key,
_value,
_proof,
_root
);
}
function get(
bytes memory _key,
bytes memory _proof,
bytes32 _root
)
public
view
returns (
bool,
bytes memory
)
{
return Lib_SecureMerkleTrie.get(
_key,
_proof,
_root
);
}
function getSingleNodeRootHash(
bytes memory _key,
bytes memory _value
)
public
view
returns (
bytes32
)
{
return Lib_SecureMerkleTrie.getSingleNodeRootHash(
_key,
_value
);
}
}
packages/contracts/build/contracts/libraries/utils/Lib_Bytes32Utils.sol → packages/contracts/contracts/test-libraries/utils/TestLib_Bytes32Utils.sol
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0; pragma solidity ^0.7.0;
/* Library Imports */
import { Lib_Bytes32Utils } from "../../optimistic-ethereum/libraries/utils/Lib_Bytes32Utils.sol";
/** /**
* @title Lib_Byte32Utils * @title TestLib_Byte32Utils
*/ */
library Lib_Bytes32Utils { library TestLib_Bytes32Utils {
/**********************
* Internal Functions *
**********************/
function toBool( function toBool(
bytes32 _in bytes32 _in
) )
internal public
pure pure
returns ( returns (
bool _out bool _out
) )
{ {
return _in != 0; return Lib_Bytes32Utils.toBool(_in);
} }
function fromBool( function fromBool(
bool _in bool _in
) )
internal public
pure pure
returns ( returns (
bytes32 _out bytes32 _out
) )
{ {
return bytes32(uint256(_in ? 1 : 0)); return Lib_Bytes32Utils.fromBool(_in);
} }
function toAddress( function toAddress(
bytes32 _in bytes32 _in
) )
internal public
pure pure
returns ( returns (
address _out address _out
) )
{ {
return address(uint160(uint256(_in))); return Lib_Bytes32Utils.toAddress(_in);
} }
function fromAddress( function fromAddress(
address _in address _in
) )
internal public
pure pure
returns ( returns (
bytes32 _out bytes32 _out
) )
{ {
return bytes32(bytes20(_in)); return Lib_Bytes32Utils.fromAddress(_in);
} }
} }
packages/contracts/contracts/test-libraries/utils/TestLib_BytesUtils.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Library Imports */
import { Lib_BytesUtils } from "../../optimistic-ethereum/libraries/utils/Lib_BytesUtils.sol";
/**
* @title TestLib_BytesUtils
*/
library TestLib_BytesUtils {
function concat(
bytes memory _preBytes,
bytes memory _postBytes
)
public
pure
returns (bytes memory)
{
return Lib_BytesUtils.concat(
_preBytes,
_postBytes
);
}
function slice(
bytes memory _bytes,
uint256 _start,
uint256 _length
)
public
pure
returns (bytes memory)
{
return Lib_BytesUtils.slice(
_bytes,
_start,
_length
);
}
function slice(
bytes memory _bytes,
uint256 _start
)
public
pure
returns (bytes memory)
{
return Lib_BytesUtils.slice(
_bytes,
_start
);
}
function toBytes32(
bytes memory _bytes
)
internal
pure
returns (bytes32)
{
return Lib_BytesUtils.toBytes32(
_bytes
);
}
function toUint256(
bytes memory _bytes
)
public
pure
returns (uint256)
{
return Lib_BytesUtils.toUint256(
_bytes
);
}
function toNibbles(
bytes memory _bytes
)
public
pure
returns (bytes memory)
{
return Lib_BytesUtils.toNibbles(
_bytes
);
}
function fromNibbles(
bytes memory _bytes
)
public
pure
returns (bytes memory)
{
return Lib_BytesUtils.fromNibbles(
_bytes
);
}
function equal(
bytes memory _bytes,
bytes memory _other
)
public
pure
returns (bool)
{
return Lib_BytesUtils.equal(
_bytes,
_other
);
}
}
packages/contracts/contracts/test-libraries/utils/TestLib_ECDSAUtils.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
/* Library Imports */
import { Lib_ECDSAUtils } from "../../optimistic-ethereum/libraries/utils/Lib_ECDSAUtils.sol";
/**
* @title TestLib_ECDSAUtils
*/
library TestLib_ECDSAUtils {
function recover(
bytes memory _message,
bool _isEthSignedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint256 _chainId
)
public
pure
returns (
address _sender
)
{
return Lib_ECDSAUtils.recover(
_message,
_isEthSignedMessage,
_v,
_r,
_s,
_chainId
);
}
}
packages/contracts/contracts/test-libraries/utils/TestLib_EthUtils.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_EthUtils } from "../../optimistic-ethereum/libraries/utils/Lib_EthUtils.sol";
/**
* @title TestLib_EthUtils
*/
library TestLib_EthUtils {
function getCode(
address _address,
uint256 _offset,
uint256 _length
)
public
view
returns (
bytes memory _code
)
{
return Lib_EthUtils.getCode(
_address,
_offset,
_length
);
}
function getCode(
address _address
)
public
view
returns (
bytes memory _code
)
{
return Lib_EthUtils.getCode(
_address
);
}
function getCodeSize(
address _address
)
public
view
returns (
uint256 _codeSize
)
{
return Lib_EthUtils.getCodeSize(
_address
);
}
function getCodeHash(
address _address
)
public
view
returns (
bytes32 _codeHash
)
{
return Lib_EthUtils.getCodeHash(
_address
);
}
function createContract(
bytes memory _code
)
public
returns (
address _created
)
{
return Lib_EthUtils.createContract(
_code
);
}
function getAddressForCREATE(
address _creator,
uint256 _nonce
)
public
view
returns (
address _address
)
{
return Lib_EthUtils.getAddressForCREATE(
_creator,
_nonce
);
}
function getAddressForCREATE2(
address _creator,
bytes memory _bytecode,
bytes32 _salt
)
public
view
returns (address _address)
{
return Lib_EthUtils.getAddressForCREATE2(
_creator,
_bytecode,
_salt
);
}
}
packages/contracts/contracts/test-libraries/utils/TestLib_MerkleUtils.sol 0 → 100644
View file @ c7b37b40
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
/* Library Imports */
import { Lib_MerkleUtils } from "../../optimistic-ethereum/libraries/utils/Lib_MerkleUtils.sol";
/**
* @title TestLib_MerkleUtils
*/
library TestLib_MerkleUtils {
function getMerkleRoot(
bytes32[] memory _hashes
)
public
view
returns (
bytes32 _root
)
{
return Lib_MerkleUtils.getMerkleRoot(
_hashes
);
}
function getMerkleRoot(
bytes[] memory _elements
)
public
view
returns (
bytes32 _root
)
{
return Lib_MerkleUtils.getMerkleRoot(
_elements
);
}
function verify(
bytes32 _root,
bytes memory _leaf,
uint256 _path,
bytes32[] memory _siblings
)
public
pure
returns (
bool _verified
)
{
return Lib_MerkleUtils.verify(
_root,
_leaf,
_path,
_siblings
);
}
}
packages/contracts/package.json
View file @ c7b37b40
...@@ -9,12 +9,13 @@ ...@@ -9,12 +9,13 @@
"build:contracts": "buidler compile", "build:contracts": "buidler compile",
"build:copy": "copyfiles -u 2 \"contracts/optimistic-ethereum/**/*.sol\" \"build/contracts\"", "build:copy": "copyfiles -u 2 \"contracts/optimistic-ethereum/**/*.sol\" \"build/contracts\"",
"test": "yarn run test:contracts", "test": "yarn run test:contracts",
"test:contracts": "buidler test", "test:contracts": "buidler test \"test/contracts/OVM/chain/OVM_StateCommitmentChain.spec.ts\" --show-stack-traces",
"lint": "tslint --format stylish --project .", "lint": "tslint --format stylish --project .",
"fix": "prettier --config prettier-config.json --write \"buidler.config.ts\" \"{src,test}/**/*.ts\"", "fix": "prettier --config prettier-config.json --write \"buidler.config.ts\" \"{src,test}/**/*.ts\"",
"clean": "rm -rf ./artifacts ./build ./cache" "clean": "rm -rf ./artifacts ./build ./cache"
}, },
"devDependencies": { "devDependencies": {
"@eth-optimism/smock": "^0.1.0",
"@nomiclabs/buidler": "^1.4.4", "@nomiclabs/buidler": "^1.4.4",
"@nomiclabs/buidler-ethers": "^2.0.0", "@nomiclabs/buidler-ethers": "^2.0.0",
"@nomiclabs/buidler-waffle": "^2.0.0", "@nomiclabs/buidler-waffle": "^2.0.0",
......
packages/contracts/test/contracts/OVM/chain/OVM_CanonicalTransactionChain.spec.ts
View file @ c7b37b40
...@@ -3,45 +3,38 @@ import { expect } from '../../../setup' ...@@ -3,45 +3,38 @@ import { expect } from '../../../setup'
/* External Imports */ /* External Imports */
import { ethers } from '@nomiclabs/buidler' import { ethers } from '@nomiclabs/buidler'
import { Signer, ContractFactory, Contract } from 'ethers' import { Signer, ContractFactory, Contract } from 'ethers'
import { smockit, MockContract } from '@eth-optimism/smock'
/* Internal Imports */ /* Internal Imports */
import { import {
getProxyManager, makeAddressManager,
MockContract,
getMockContract,
setProxyTarget, setProxyTarget,
getEthTime,
setEthTime,
NON_NULL_BYTES32, NON_NULL_BYTES32,
FORCE_INCLUSION_PERIOD_SECONDS, FORCE_INCLUSION_PERIOD_SECONDS,
ZERO_ADDRESS, ZERO_ADDRESS,
} from '../../../helpers' } from '../../../helpers'
const getEthTime = async (): Promise<number> => {
return (await ethers.provider.getBlock('latest')).timestamp
}
const setEthTime = async (time: number): Promise<void> => {
await ethers.provider.send('evm_setNextBlockTimestamp', [time])
}
describe('OVM_CanonicalTransactionChain', () => { describe('OVM_CanonicalTransactionChain', () => {
let signer: Signer let signer: Signer
before(async () => { before(async () => {
;[signer] = await ethers.getSigners() ;[signer] = await ethers.getSigners()
}) })
let Proxy_Manager: Contract let AddressManager: Contract
before(async () => { before(async () => {
Proxy_Manager = await getProxyManager() AddressManager = await makeAddressManager()
}) })
let Mock__OVM_L1ToL2TransactionQueue: MockContract let Mock__OVM_L1ToL2TransactionQueue: MockContract
before(async () => { before(async () => {
Mock__OVM_L1ToL2TransactionQueue = await getMockContract( Mock__OVM_L1ToL2TransactionQueue = smockit(
await ethers.getContractFactory('OVM_L1ToL2TransactionQueue') await ethers.getContractFactory('OVM_L1ToL2TransactionQueue')
) )
await setProxyTarget( await setProxyTarget(
Proxy_Manager, AddressManager,
'OVM_L1ToL2TransactionQueue', 'OVM_L1ToL2TransactionQueue',
Mock__OVM_L1ToL2TransactionQueue Mock__OVM_L1ToL2TransactionQueue
) )
...@@ -57,7 +50,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -57,7 +50,7 @@ describe('OVM_CanonicalTransactionChain', () => {
let OVM_CanonicalTransactionChain: Contract let OVM_CanonicalTransactionChain: Contract
beforeEach(async () => { beforeEach(async () => {
OVM_CanonicalTransactionChain = await Factory__OVM_CanonicalTransactionChain.deploy( OVM_CanonicalTransactionChain = await Factory__OVM_CanonicalTransactionChain.deploy(
Proxy_Manager.address, AddressManager.address,
FORCE_INCLUSION_PERIOD_SECONDS FORCE_INCLUSION_PERIOD_SECONDS
) )
}) })
...@@ -65,7 +58,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -65,7 +58,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('appendQueueBatch()', () => { describe('appendQueueBatch()', () => {
describe('when the L1ToL2TransactionQueue queue is empty', () => { describe('when the L1ToL2TransactionQueue queue is empty', () => {
before(() => { before(() => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [0]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(0)
}) })
it('should revert', async () => { it('should revert', async () => {
...@@ -77,20 +70,24 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -77,20 +70,24 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when the L1ToL2TransactionQueue queue is not empty', () => { describe('when the L1ToL2TransactionQueue queue is not empty', () => {
before(() => { before(() => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [1]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(1)
}) })
describe('when the inclusion delay period has not elapsed', () => { describe('when the inclusion delay period has not elapsed', () => {
beforeEach(async () => { beforeEach(async () => {
const timestamp = await getEthTime() const timestamp = await getEthTime(ethers.provider)
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('peek', [ Mock__OVM_L1ToL2TransactionQueue.smocked.peek.will.return.with([
{ {
timestamp, timestamp,
batchRoot: NON_NULL_BYTES32, batchRoot: NON_NULL_BYTES32,
isL1ToL2Batch: true, isL1ToL2Batch: true,
}, },
]) ])
await setEthTime(timestamp + FORCE_INCLUSION_PERIOD_SECONDS / 2)
await setEthTime(
ethers.provider,
timestamp + FORCE_INCLUSION_PERIOD_SECONDS / 2
)
}) })
it('should revert', async () => { it('should revert', async () => {
...@@ -104,22 +101,20 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -104,22 +101,20 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when the inclusion delay period has elapsed', () => { describe('when the inclusion delay period has elapsed', () => {
beforeEach(async () => { beforeEach(async () => {
const timestamp = await getEthTime() const timestamp = await getEthTime(ethers.provider)
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('peek', [ Mock__OVM_L1ToL2TransactionQueue.smocked.dequeue.will.return()
{ Mock__OVM_L1ToL2TransactionQueue.smocked.peek.will.return.with([
timestamp,
batchRoot: NON_NULL_BYTES32,
isL1ToL2Batch: true,
},
])
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('dequeue', [
{ {
timestamp, timestamp,
batchRoot: NON_NULL_BYTES32, batchRoot: NON_NULL_BYTES32,
isL1ToL2Batch: true, isL1ToL2Batch: true,
}, },
]) ])
await setEthTime(timestamp + FORCE_INCLUSION_PERIOD_SECONDS)
await setEthTime(
ethers.provider,
timestamp + FORCE_INCLUSION_PERIOD_SECONDS
)
}) })
it('should append the top element of the queue and attempt to dequeue', async () => { it('should append the top element of the queue and attempt to dequeue', async () => {
...@@ -129,7 +124,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -129,7 +124,7 @@ describe('OVM_CanonicalTransactionChain', () => {
// TODO: Check that the batch root was inserted. // TODO: Check that the batch root was inserted.
expect( expect(
Mock__OVM_L1ToL2TransactionQueue.getCallCount('dequeue') Mock__OVM_L1ToL2TransactionQueue.smocked.dequeue.calls.length
).to.equal(1) ).to.equal(1)
}) })
}) })
...@@ -139,7 +134,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -139,7 +134,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('appendSequencerBatch()', () => { describe('appendSequencerBatch()', () => {
describe('when the sender is not the sequencer', () => { describe('when the sender is not the sequencer', () => {
before(async () => { before(async () => {
await Proxy_Manager.setProxy('Sequencer', ZERO_ADDRESS) await AddressManager.setAddress('Sequencer', ZERO_ADDRESS)
}) })
it('should revert', async () => { it('should revert', async () => {
...@@ -151,7 +146,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -151,7 +146,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when the sender is the sequencer', () => { describe('when the sender is the sequencer', () => {
before(async () => { before(async () => {
await Proxy_Manager.setProxy('Sequencer', await signer.getAddress()) await AddressManager.setAddress('Sequencer', await signer.getAddress())
}) })
describe('when the given batch is empty', () => { describe('when the given batch is empty', () => {
...@@ -187,12 +182,12 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -187,12 +182,12 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when the queue is not empty', () => { describe('when the queue is not empty', () => {
before(() => { before(() => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [1]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(1)
}) })
describe('when the first element in the queue is older than the provided batch', () => { describe('when the first element in the queue is older than the provided batch', () => {
before(() => { before(() => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('peek', [ Mock__OVM_L1ToL2TransactionQueue.smocked.peek.will.return.with([
{ {
timestamp: timestamp / 2, timestamp: timestamp / 2,
batchRoot: NON_NULL_BYTES32, batchRoot: NON_NULL_BYTES32,
...@@ -215,7 +210,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -215,7 +210,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when the first element in the queue is not older than the provided batch', () => { describe('when the first element in the queue is not older than the provided batch', () => {
before(() => { before(() => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('peek', [ Mock__OVM_L1ToL2TransactionQueue.smocked.peek.will.return.with([
{ {
timestamp, timestamp,
batchRoot: NON_NULL_BYTES32, batchRoot: NON_NULL_BYTES32,
...@@ -239,7 +234,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -239,7 +234,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when the queue is empty', async () => { describe('when the queue is empty', async () => {
before(() => { before(() => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [0]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(0)
}) })
it('should insert the sequencer batch', async () => { it('should insert the sequencer batch', async () => {
...@@ -269,7 +264,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -269,7 +264,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when one batch element has been inserted', () => { describe('when one batch element has been inserted', () => {
beforeEach(async () => { beforeEach(async () => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [0]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(0)
await OVM_CanonicalTransactionChain.appendSequencerBatch( await OVM_CanonicalTransactionChain.appendSequencerBatch(
[NON_NULL_BYTES32], [NON_NULL_BYTES32],
1000 1000
...@@ -286,7 +281,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -286,7 +281,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when 64 batch elements have been inserted in one batch', () => { describe('when 64 batch elements have been inserted in one batch', () => {
const batch = Array(64).fill(NON_NULL_BYTES32) const batch = Array(64).fill(NON_NULL_BYTES32)
beforeEach(async () => { beforeEach(async () => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [0]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(0)
await OVM_CanonicalTransactionChain.appendSequencerBatch(batch, 1000) await OVM_CanonicalTransactionChain.appendSequencerBatch(batch, 1000)
}) })
...@@ -300,7 +295,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -300,7 +295,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when 32 batch elements have been inserted in each of two batches', () => { describe('when 32 batch elements have been inserted in each of two batches', () => {
const batch = Array(32).fill(NON_NULL_BYTES32) const batch = Array(32).fill(NON_NULL_BYTES32)
beforeEach(async () => { beforeEach(async () => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [0]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(0)
await OVM_CanonicalTransactionChain.appendSequencerBatch(batch, 1000) await OVM_CanonicalTransactionChain.appendSequencerBatch(batch, 1000)
await OVM_CanonicalTransactionChain.appendSequencerBatch(batch, 2000) await OVM_CanonicalTransactionChain.appendSequencerBatch(batch, 2000)
}) })
...@@ -324,7 +319,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -324,7 +319,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when one batch has been inserted', () => { describe('when one batch has been inserted', () => {
beforeEach(async () => { beforeEach(async () => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [0]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(0)
await OVM_CanonicalTransactionChain.appendSequencerBatch( await OVM_CanonicalTransactionChain.appendSequencerBatch(
[NON_NULL_BYTES32], [NON_NULL_BYTES32],
1000 1000
...@@ -340,7 +335,7 @@ describe('OVM_CanonicalTransactionChain', () => { ...@@ -340,7 +335,7 @@ describe('OVM_CanonicalTransactionChain', () => {
describe('when 8 batches have been inserted', () => { describe('when 8 batches have been inserted', () => {
beforeEach(async () => { beforeEach(async () => {
Mock__OVM_L1ToL2TransactionQueue.setReturnValues('size', [0]) Mock__OVM_L1ToL2TransactionQueue.smocked.size.will.return.with(0)
for (let i = 0; i < 8; i++) { for (let i = 0; i < 8; i++) {
await OVM_CanonicalTransactionChain.appendSequencerBatch( await OVM_CanonicalTransactionChain.appendSequencerBatch(
[NON_NULL_BYTES32], [NON_NULL_BYTES32],
......
packages/contracts/test/contracts/OVM/chain/OVM_StateCommitmentChain.spec.ts
View file @ c7b37b40
...@@ -3,16 +3,16 @@ import { expect } from '../../../setup' ...@@ -3,16 +3,16 @@ import { expect } from '../../../setup'
/* External Imports */ /* External Imports */
import { ethers } from '@nomiclabs/buidler' import { ethers } from '@nomiclabs/buidler'
import { Signer, ContractFactory, Contract } from 'ethers' import { Signer, ContractFactory, Contract } from 'ethers'
import { smockit, MockContract } from '@eth-optimism/smock'
/* Internal Imports */ /* Internal Imports */
import { import {
getProxyManager, makeAddressManager,
MockContract,
getMockContract,
setProxyTarget, setProxyTarget,
NON_NULL_BYTES32, NON_NULL_BYTES32,
ZERO_ADDRESS, ZERO_ADDRESS,
} from '../../../helpers' } from '../../../helpers'
import { keccak256 } from 'ethers/lib/utils'
describe('OVM_StateCommitmentChain', () => { describe('OVM_StateCommitmentChain', () => {
let signer: Signer let signer: Signer
...@@ -20,19 +20,19 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -20,19 +20,19 @@ describe('OVM_StateCommitmentChain', () => {
;[signer] = await ethers.getSigners() ;[signer] = await ethers.getSigners()
}) })
let Proxy_Manager: Contract let AddressManager: Contract
before(async () => { before(async () => {
Proxy_Manager = await getProxyManager() AddressManager = await makeAddressManager()
}) })
let Mock__OVM_CanonicalTransactionChain: MockContract let Mock__OVM_CanonicalTransactionChain: MockContract
before(async () => { before(async () => {
Mock__OVM_CanonicalTransactionChain = await getMockContract( Mock__OVM_CanonicalTransactionChain = smockit(
await ethers.getContractFactory('OVM_CanonicalTransactionChain') await ethers.getContractFactory('OVM_CanonicalTransactionChain')
) )
await setProxyTarget( await setProxyTarget(
Proxy_Manager, AddressManager,
'OVM_CanonicalTransactionChain', 'OVM_CanonicalTransactionChain',
Mock__OVM_CanonicalTransactionChain Mock__OVM_CanonicalTransactionChain
) )
...@@ -48,7 +48,7 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -48,7 +48,7 @@ describe('OVM_StateCommitmentChain', () => {
let OVM_StateCommitmentChain: Contract let OVM_StateCommitmentChain: Contract
beforeEach(async () => { beforeEach(async () => {
OVM_StateCommitmentChain = await Factory__OVM_StateCommitmentChain.deploy( OVM_StateCommitmentChain = await Factory__OVM_StateCommitmentChain.deploy(
Proxy_Manager.address AddressManager.address
) )
}) })
...@@ -68,9 +68,8 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -68,9 +68,8 @@ describe('OVM_StateCommitmentChain', () => {
describe('when submitting more elements than present in the OVM_CanonicalTransactionChain', () => { describe('when submitting more elements than present in the OVM_CanonicalTransactionChain', () => {
before(() => { before(() => {
Mock__OVM_CanonicalTransactionChain.setReturnValues( Mock__OVM_CanonicalTransactionChain.smocked.getTotalElements.will.return.with(
'getTotalElements', batch.length - 1
[batch.length - 1]
) )
}) })
...@@ -85,43 +84,39 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -85,43 +84,39 @@ describe('OVM_StateCommitmentChain', () => {
describe('when not submitting more elements than present in the OVM_CanonicalTransactionChain', () => { describe('when not submitting more elements than present in the OVM_CanonicalTransactionChain', () => {
before(() => { before(() => {
Mock__OVM_CanonicalTransactionChain.setReturnValues( Mock__OVM_CanonicalTransactionChain.smocked.getTotalElements.will.return.with(
'getTotalElements', batch.length
[batch.length]
) )
}) })
it('should append the state batch', async () => { it('should append the state batch', async () => {
await expect(OVM_StateCommitmentChain.appendStateBatch(batch)).to.not await expect(OVM_StateCommitmentChain.appendStateBatch(batch)).to.not
.be.reverted .be.reverted
// TODO: Check for correct insertion.
}) })
}) })
}) })
}) })
describe('deleteStateBatch', () => { describe('deleteStateBatch', () => {
// TODO: Calculate the right header.
const batch = [NON_NULL_BYTES32] const batch = [NON_NULL_BYTES32]
const batchHeader = { const batchHeader = {
batchIndex: 0, batchIndex: 0,
batchRoot: NON_NULL_BYTES32, batchRoot: keccak256(NON_NULL_BYTES32),
batchSize: 0, batchSize: 1,
prevTotalElements: 0, prevTotalElements: 0,
extraData: '0x', extraData: '0x',
} }
beforeEach(async () => { beforeEach(async () => {
Mock__OVM_CanonicalTransactionChain.setReturnValues('getTotalElements', [ Mock__OVM_CanonicalTransactionChain.smocked.getTotalElements.will.return.with(
batch.length, batch.length
]) )
await OVM_StateCommitmentChain.appendStateBatch(batch) await OVM_StateCommitmentChain.appendStateBatch(batch)
}) })
describe('when the sender is not the OVM_FraudVerifier', () => { describe('when the sender is not the OVM_FraudVerifier', () => {
before(async () => { before(async () => {
await Proxy_Manager.setProxy('OVM_FraudVerifier', ZERO_ADDRESS) await AddressManager.setAddress('OVM_FraudVerifier', ZERO_ADDRESS)
}) })
it('should revert', async () => { it('should revert', async () => {
...@@ -135,7 +130,7 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -135,7 +130,7 @@ describe('OVM_StateCommitmentChain', () => {
describe('when the sender is the OVM_FraudVerifier', () => { describe('when the sender is the OVM_FraudVerifier', () => {
before(async () => { before(async () => {
await Proxy_Manager.setProxy( await AddressManager.setAddress(
'OVM_FraudVerifier', 'OVM_FraudVerifier',
await signer.getAddress() await signer.getAddress()
) )
...@@ -168,8 +163,6 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -168,8 +163,6 @@ describe('OVM_StateCommitmentChain', () => {
it('should remove the batch and all following batches', async () => { it('should remove the batch and all following batches', async () => {
await expect(OVM_StateCommitmentChain.deleteStateBatch(batchHeader)) await expect(OVM_StateCommitmentChain.deleteStateBatch(batchHeader))
.to.not.be.reverted .to.not.be.reverted
// TODO: Check that it deleted the batches.
}) })
}) })
}) })
...@@ -186,9 +179,8 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -186,9 +179,8 @@ describe('OVM_StateCommitmentChain', () => {
describe('when one batch element has been inserted', () => { describe('when one batch element has been inserted', () => {
beforeEach(async () => { beforeEach(async () => {
const batch = [NON_NULL_BYTES32] const batch = [NON_NULL_BYTES32]
Mock__OVM_CanonicalTransactionChain.setReturnValues( Mock__OVM_CanonicalTransactionChain.smocked.getTotalElements.will.return.with(
'getTotalElements', batch.length
[batch.length]
) )
await OVM_StateCommitmentChain.appendStateBatch(batch) await OVM_StateCommitmentChain.appendStateBatch(batch)
}) })
...@@ -201,9 +193,8 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -201,9 +193,8 @@ describe('OVM_StateCommitmentChain', () => {
describe('when 64 batch elements have been inserted in one batch', () => { describe('when 64 batch elements have been inserted in one batch', () => {
beforeEach(async () => { beforeEach(async () => {
const batch = Array(64).fill(NON_NULL_BYTES32) const batch = Array(64).fill(NON_NULL_BYTES32)
Mock__OVM_CanonicalTransactionChain.setReturnValues( Mock__OVM_CanonicalTransactionChain.smocked.getTotalElements.will.return.with(
'getTotalElements', batch.length
[batch.length]
) )
await OVM_StateCommitmentChain.appendStateBatch(batch) await OVM_StateCommitmentChain.appendStateBatch(batch)
}) })
...@@ -216,9 +207,8 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -216,9 +207,8 @@ describe('OVM_StateCommitmentChain', () => {
describe('when 32 batch elements have been inserted in each of two batches', () => { describe('when 32 batch elements have been inserted in each of two batches', () => {
beforeEach(async () => { beforeEach(async () => {
const batch = Array(32).fill(NON_NULL_BYTES32) const batch = Array(32).fill(NON_NULL_BYTES32)
Mock__OVM_CanonicalTransactionChain.setReturnValues( Mock__OVM_CanonicalTransactionChain.smocked.getTotalElements.will.return.with(
'getTotalElements', batch.length * 2
[batch.length * 2]
) )
await OVM_StateCommitmentChain.appendStateBatch(batch) await OVM_StateCommitmentChain.appendStateBatch(batch)
await OVM_StateCommitmentChain.appendStateBatch(batch) await OVM_StateCommitmentChain.appendStateBatch(batch)
...@@ -240,9 +230,8 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -240,9 +230,8 @@ describe('OVM_StateCommitmentChain', () => {
describe('when one batch has been inserted', () => { describe('when one batch has been inserted', () => {
beforeEach(async () => { beforeEach(async () => {
const batch = [NON_NULL_BYTES32] const batch = [NON_NULL_BYTES32]
Mock__OVM_CanonicalTransactionChain.setReturnValues( Mock__OVM_CanonicalTransactionChain.smocked.getTotalElements.will.return.with(
'getTotalElements', batch.length
[batch.length]
) )
await OVM_StateCommitmentChain.appendStateBatch(batch) await OVM_StateCommitmentChain.appendStateBatch(batch)
}) })
...@@ -255,10 +244,10 @@ describe('OVM_StateCommitmentChain', () => { ...@@ -255,10 +244,10 @@ describe('OVM_StateCommitmentChain', () => {
describe('when 8 batches have been inserted', () => { describe('when 8 batches have been inserted', () => {
beforeEach(async () => { beforeEach(async () => {
const batch = [NON_NULL_BYTES32] const batch = [NON_NULL_BYTES32]
Mock__OVM_CanonicalTransactionChain.setReturnValues( Mock__OVM_CanonicalTransactionChain.smocked.getTotalElements.will.return.with(
'getTotalElements', batch.length * 8
[batch.length * 8]
) )
for (let i = 0; i < 8; i++) { for (let i = 0; i < 8; i++) {
await OVM_StateCommitmentChain.appendStateBatch(batch) await OVM_StateCommitmentChain.appendStateBatch(batch)
} }
......
packages/contracts/test/contracts/OVM/execution/OVM_ExecutionManager/ovmCALL.spec.ts
View file @ c7b37b40
...@@ -39,9 +39,9 @@ const test_ovmCALL: TestDefinition = { ...@@ -39,9 +39,9 @@ const test_ovmCALL: TestDefinition = {
}, },
verifiedContractStorage: { verifiedContractStorage: {
$DUMMY_OVM_ADDRESS_1: { $DUMMY_OVM_ADDRESS_1: {
[NON_NULL_BYTES32]: true [NON_NULL_BYTES32]: true,
} },
} },
}, },
}, },
parameters: [ parameters: [
......
packages/contracts/test/contracts/OVM/execution/OVM_ExecutionManager/ovmCREATE.spec.ts
View file @ c7b37b40
...@@ -11,7 +11,7 @@ import { ...@@ -11,7 +11,7 @@ import {
VERIFIED_EMPTY_CONTRACT_HASH, VERIFIED_EMPTY_CONTRACT_HASH,
DUMMY_BYTECODE_BYTELEN, DUMMY_BYTECODE_BYTELEN,
DUMMY_BYTECODE_HASH, DUMMY_BYTECODE_HASH,
getStorageXOR getStorageXOR,
} from '../../../../helpers' } from '../../../../helpers'
const CREATED_CONTRACT_1 = '0x2bda4a99d5be88609d23b1e4ab5d1d34fb1c2feb' const CREATED_CONTRACT_1 = '0x2bda4a99d5be88609d23b1e4ab5d1d34fb1c2feb'
......
packages/contracts/test/contracts/OVM/execution/OVM_ExecutionManager/ovmDELEGATECALL.spec.ts
View file @ c7b37b40
...@@ -53,9 +53,9 @@ const test_ovmDELEGATECALL: TestDefinition = { ...@@ -53,9 +53,9 @@ const test_ovmDELEGATECALL: TestDefinition = {
}, },
verifiedContractStorage: { verifiedContractStorage: {
$DUMMY_OVM_ADDRESS_1: { $DUMMY_OVM_ADDRESS_1: {
[NON_NULL_BYTES32]: true [NON_NULL_BYTES32]: true,
} },
} },
}, },
}, },
parameters: [ parameters: [
......
packages/contracts/test/contracts/OVM/execution/OVM_ExecutionManager/ovmREVERT.spec.ts
View file @ c7b37b40
...@@ -51,7 +51,7 @@ const test_ovmREVERT: TestDefinition = { ...@@ -51,7 +51,7 @@ const test_ovmREVERT: TestDefinition = {
], ],
}, },
expectedReturnStatus: false, expectedReturnStatus: false,
expectedReturnValue: '0xdeadbeef' expectedReturnValue: '0xdeadbeef',
}, },
], ],
}, },
......
packages/contracts/test/contracts/OVM/execution/OVM_ExecutionManager/ovmSLOAD.spec.ts
View file @ c7b37b40
...@@ -55,7 +55,7 @@ const test_ovmSLOAD: TestDefinition = { ...@@ -55,7 +55,7 @@ const test_ovmSLOAD: TestDefinition = {
{ {
functionName: 'ovmSLOAD', functionName: 'ovmSLOAD',
functionParams: { functionParams: {
key: NON_NULL_BYTES32 key: NON_NULL_BYTES32,
}, },
expectedReturnStatus: true, expectedReturnStatus: true,
expectedReturnValue: NULL_BYTES32, expectedReturnValue: NULL_BYTES32,
......
packages/contracts/test/contracts/OVM/execution/OVM_ExecutionManager/ovmSTATICCALL.spec.ts
View file @ c7b37b40
...@@ -68,19 +68,19 @@ const test_ovmSTATICCALL: TestDefinition = { ...@@ -68,19 +68,19 @@ const test_ovmSTATICCALL: TestDefinition = {
functionName: 'ovmSSTORE', functionName: 'ovmSSTORE',
functionParams: { functionParams: {
key: NULL_BYTES32, key: NULL_BYTES32,
value: NULL_BYTES32 value: NULL_BYTES32,
}, },
expectedReturnStatus: false, expectedReturnStatus: false,
expectedReturnValue: { expectedReturnValue: {
flag: REVERT_FLAGS.STATIC_VIOLATION, flag: REVERT_FLAGS.STATIC_VIOLATION,
nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2 nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2,
}
}
]
}, },
expectedReturnStatus: false },
} ],
] },
expectedReturnStatus: false,
},
],
}, },
{ {
name: 'ovmSTATICCALL => ovmSLOAD', name: 'ovmSTATICCALL => ovmSLOAD',
...@@ -97,13 +97,13 @@ const test_ovmSTATICCALL: TestDefinition = { ...@@ -97,13 +97,13 @@ const test_ovmSTATICCALL: TestDefinition = {
key: NON_NULL_BYTES32, key: NON_NULL_BYTES32,
}, },
expectedReturnStatus: true, expectedReturnStatus: true,
expectedReturnValue: NULL_BYTES32 expectedReturnValue: NULL_BYTES32,
} },
] ],
},
expectedReturnStatus: true,
}, },
expectedReturnStatus: true ],
}
]
}, },
{ {
name: 'ovmSTATICCALL => ovmCREATE', name: 'ovmSTATICCALL => ovmCREATE',
...@@ -122,14 +122,14 @@ const test_ovmSTATICCALL: TestDefinition = { ...@@ -122,14 +122,14 @@ const test_ovmSTATICCALL: TestDefinition = {
expectedReturnStatus: false, expectedReturnStatus: false,
expectedReturnValue: { expectedReturnValue: {
flag: REVERT_FLAGS.STATIC_VIOLATION, flag: REVERT_FLAGS.STATIC_VIOLATION,
nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2 nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2,
} },
} },
] ],
}, },
expectedReturnStatus: false expectedReturnStatus: false,
} },
] ],
}, },
{ {
name: 'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmCALLER', name: 'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmCALLER',
...@@ -148,17 +148,17 @@ const test_ovmSTATICCALL: TestDefinition = { ...@@ -148,17 +148,17 @@ const test_ovmSTATICCALL: TestDefinition = {
subSteps: [ subSteps: [
{ {
functionName: 'ovmCALLER', functionName: 'ovmCALLER',
expectedReturnValue: '$DUMMY_OVM_ADDRESS_1' expectedReturnValue: '$DUMMY_OVM_ADDRESS_1',
}
]
}, },
expectedReturnStatus: true ],
}
]
}, },
expectedReturnStatus: true expectedReturnStatus: true,
} },
] ],
},
expectedReturnStatus: true,
},
],
}, },
{ {
name: 'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmADDRESS', name: 'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmADDRESS',
...@@ -177,20 +177,21 @@ const test_ovmSTATICCALL: TestDefinition = { ...@@ -177,20 +177,21 @@ const test_ovmSTATICCALL: TestDefinition = {
subSteps: [ subSteps: [
{ {
functionName: 'ovmADDRESS', functionName: 'ovmADDRESS',
expectedReturnValue: '$DUMMY_OVM_ADDRESS_2' expectedReturnValue: '$DUMMY_OVM_ADDRESS_2',
} },
] ],
}, },
expectedReturnStatus: true expectedReturnStatus: true,
}
]
}, },
expectedReturnStatus: true ],
} },
] expectedReturnStatus: true,
},
],
}, },
{ {
name: 'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmCALL(ADDRESS_3) => ovmSSTORE', name:
'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmCALL(ADDRESS_3) => ovmSSTORE',
steps: [ steps: [
{ {
functionName: 'ovmCALL', functionName: 'ovmCALL',
...@@ -214,34 +215,35 @@ const test_ovmSTATICCALL: TestDefinition = { ...@@ -214,34 +215,35 @@ const test_ovmSTATICCALL: TestDefinition = {
functionName: 'ovmSSTORE', functionName: 'ovmSSTORE',
functionParams: { functionParams: {
key: NULL_BYTES32, key: NULL_BYTES32,
value: NULL_BYTES32 value: NULL_BYTES32,
}, },
expectedReturnStatus: false, expectedReturnStatus: false,
expectedReturnValue: { expectedReturnValue: {
flag: REVERT_FLAGS.STATIC_VIOLATION, flag: REVERT_FLAGS.STATIC_VIOLATION,
nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2 nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2,
} },
} },
] ],
}, },
expectedReturnStatus: false, expectedReturnStatus: false,
expectedReturnValue: { expectedReturnValue: {
flag: REVERT_FLAGS.STATIC_VIOLATION, flag: REVERT_FLAGS.STATIC_VIOLATION,
nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2 nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2,
}
}
]
}, },
expectedReturnStatus: false
}
]
}, },
expectedReturnStatus: true ],
} },
] expectedReturnStatus: false,
},
],
},
expectedReturnStatus: true,
},
],
}, },
{ {
name: 'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmCALL(ADDRESS_3) => ovmSLOAD', name:
'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmCALL(ADDRESS_3) => ovmSLOAD',
steps: [ steps: [
{ {
functionName: 'ovmCALL', functionName: 'ovmCALL',
...@@ -267,24 +269,25 @@ const test_ovmSTATICCALL: TestDefinition = { ...@@ -267,24 +269,25 @@ const test_ovmSTATICCALL: TestDefinition = {
key: NON_NULL_BYTES32, key: NON_NULL_BYTES32,
}, },
expectedReturnStatus: true, expectedReturnStatus: true,
expectedReturnValue: NULL_BYTES32 expectedReturnValue: NULL_BYTES32,
} },
] ],
},
expectedReturnStatus: true,
},
],
},
expectedReturnStatus: true,
}, },
expectedReturnStatus: true ],
}
]
}, },
expectedReturnStatus: true expectedReturnStatus: true,
}
]
}, },
expectedReturnStatus: true ],
}
]
}, },
{ {
name: 'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmCALL(ADDRESS_3) => ovmCREATE', name:
'ovmCALL(ADDRESS_1) => ovmSTATICCALL(ADDRESS_2) => ovmCALL(ADDRESS_3) => ovmCREATE',
steps: [ steps: [
{ {
functionName: 'ovmCALL', functionName: 'ovmCALL',
...@@ -307,33 +310,33 @@ const test_ovmSTATICCALL: TestDefinition = { ...@@ -307,33 +310,33 @@ const test_ovmSTATICCALL: TestDefinition = {
{ {
functionName: 'ovmCREATE', functionName: 'ovmCREATE',
functionParams: { functionParams: {
bytecode: DUMMY_BYTECODE bytecode: DUMMY_BYTECODE,
}, },
expectedReturnStatus: false, expectedReturnStatus: false,
expectedReturnValue: { expectedReturnValue: {
flag: REVERT_FLAGS.STATIC_VIOLATION, flag: REVERT_FLAGS.STATIC_VIOLATION,
nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2 nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2,
} },
} },
] ],
}, },
expectedReturnStatus: false, expectedReturnStatus: false,
expectedReturnValue: { expectedReturnValue: {
flag: REVERT_FLAGS.STATIC_VIOLATION, flag: REVERT_FLAGS.STATIC_VIOLATION,
nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2 nuisanceGasLeft: OVM_TX_GAS_LIMIT / 2,
} },
}
]
}, },
expectedReturnStatus: false ],
} },
] expectedReturnStatus: false,
},
],
},
expectedReturnStatus: true,
}, },
expectedReturnStatus: true ],
}
]
}, },
] ],
} }
const runner = new ExecutionManagerTestRunner() const runner = new ExecutionManagerTestRunner()
......
packages/contracts/test/contracts/OVM/execution/OVM_StateManager.spec.ts
View file @ c7b37b40
...@@ -2,12 +2,25 @@ import { expect } from '../../../setup' ...@@ -2,12 +2,25 @@ import { expect } from '../../../setup'
/* External Imports */ /* External Imports */
import { ethers } from '@nomiclabs/buidler' import { ethers } from '@nomiclabs/buidler'
import { Contract, ContractFactory } from 'ethers' import { Contract, ContractFactory, Signer, BigNumber } from 'ethers'
import _ from 'lodash'
/* Internal Imports */ /* Internal Imports */
import { DUMMY_ACCOUNTS, DUMMY_BYTES32, toOVMAccount } from '../../../helpers' import { DUMMY_ACCOUNTS, DUMMY_BYTES32, ZERO_ADDRESS } from '../../../helpers'
const EMPTY_ACCOUNT_CODE_HASH =
'0x00004B1DC0DE000000004B1DC0DE000000004B1DC0DE000000004B1DC0DE0000'
const RLP_NULL_HASH =
'0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421'
describe('OVM_StateManager', () => { describe('OVM_StateManager', () => {
let signer1: Signer
let signer2: Signer
let signer3: Signer
before(async () => {
;[signer1, signer2, signer3] = await ethers.getSigners()
})
let Factory__OVM_StateManager: ContractFactory let Factory__OVM_StateManager: ContractFactory
before(async () => { before(async () => {
Factory__OVM_StateManager = await ethers.getContractFactory( Factory__OVM_StateManager = await ethers.getContractFactory(
...@@ -17,7 +30,65 @@ describe('OVM_StateManager', () => { ...@@ -17,7 +30,65 @@ describe('OVM_StateManager', () => {
let OVM_StateManager: Contract let OVM_StateManager: Contract
beforeEach(async () => { beforeEach(async () => {
OVM_StateManager = await Factory__OVM_StateManager.deploy() OVM_StateManager = (
await Factory__OVM_StateManager.deploy(await signer1.getAddress())
).connect(signer1)
})
describe('setExecutionManager', () => {
describe('when called by the current owner', () => {
beforeEach(async () => {
OVM_StateManager = OVM_StateManager.connect(signer1)
})
it('should change the current OVM_ExecutionManager', async () => {
await expect(
OVM_StateManager.connect(signer1).setExecutionManager(
await signer2.getAddress()
)
).to.not.be.reverted
expect(await OVM_StateManager.ovmExecutionManager()).to.equal(
await signer2.getAddress()
)
})
})
describe('when called by the current OVM_ExecutionManager', () => {
beforeEach(async () => {
await OVM_StateManager.connect(signer1).setExecutionManager(
await signer2.getAddress()
)
})
it('should change the current OVM_ExecutionManager', async () => {
await expect(
OVM_StateManager.connect(signer2).setExecutionManager(
await signer3.getAddress()
)
).to.not.be.reverted
expect(await OVM_StateManager.ovmExecutionManager()).to.equal(
await signer3.getAddress()
)
})
})
describe('when called by any other account', () => {
beforeEach(async () => {
OVM_StateManager = OVM_StateManager.connect(signer1)
})
it('should revert', async () => {
await expect(
OVM_StateManager.connect(signer3).setExecutionManager(
await signer3.getAddress()
)
).to.be.revertedWith(
'Function can only be called by authenticated addresses'
)
})
})
}) })
describe('putAccount', () => { describe('putAccount', () => {
...@@ -53,12 +124,12 @@ describe('OVM_StateManager', () => { ...@@ -53,12 +124,12 @@ describe('OVM_StateManager', () => {
) )
expect( expect(
toOVMAccount( _.toPlainObject(
await OVM_StateManager.callStatic.getAccount( await OVM_StateManager.callStatic.getAccount(
DUMMY_ACCOUNTS[0].address DUMMY_ACCOUNTS[0].address
) )
) )
).to.deep.equal(DUMMY_ACCOUNTS[0].data) ).to.deep.include(DUMMY_ACCOUNTS[0].data)
}) })
it('should be able to retrieve an overwritten OVM account', async () => { it('should be able to retrieve an overwritten OVM account', async () => {
...@@ -73,97 +144,837 @@ describe('OVM_StateManager', () => { ...@@ -73,97 +144,837 @@ describe('OVM_StateManager', () => {
) )
expect( expect(
toOVMAccount( _.toPlainObject(
await OVM_StateManager.callStatic.getAccount( await OVM_StateManager.callStatic.getAccount(
DUMMY_ACCOUNTS[0].address DUMMY_ACCOUNTS[0].address
) )
) )
).to.deep.equal(DUMMY_ACCOUNTS[1].data) ).to.deep.include(DUMMY_ACCOUNTS[1].data)
}) })
}) })
describe('hasAccount', () => { describe('hasAccount', () => {
it('should return true if an account exists', async () => { describe('when the account exists', () => {
beforeEach(async () => {
await OVM_StateManager.putAccount( await OVM_StateManager.putAccount(
DUMMY_ACCOUNTS[0].address, DUMMY_ACCOUNTS[0].address,
DUMMY_ACCOUNTS[0].data DUMMY_ACCOUNTS[0].data
) )
})
it('should return true', async () => {
expect( expect(
await OVM_StateManager.callStatic.hasAccount(DUMMY_ACCOUNTS[0].address) await OVM_StateManager.callStatic.hasAccount(
DUMMY_ACCOUNTS[0].address
)
).to.equal(true) ).to.equal(true)
}) })
})
it('should return false if the account does not exist', async () => { describe('when the account does not exist', () => {
it('should return false', async () => {
expect( expect(
await OVM_StateManager.callStatic.hasAccount(DUMMY_ACCOUNTS[0].address) await OVM_StateManager.callStatic.hasAccount(
DUMMY_ACCOUNTS[0].address
)
).to.equal(false) ).to.equal(false)
}) })
}) })
})
describe('putContractStorage', () => { describe('hasEmptyAccount', () => {
it('should be able to insert a storage slot for a given contract', async () => { describe('when the account has the EMPTY_ACCOUNT_CODE_HASH', () => {
await expect( beforeEach(async () => {
OVM_StateManager.putContractStorage( await OVM_StateManager.putAccount(DUMMY_ACCOUNTS[0].address, {
DUMMY_ACCOUNTS[0].address, ...DUMMY_ACCOUNTS[0].data,
DUMMY_BYTES32[0], codeHash: EMPTY_ACCOUNT_CODE_HASH,
DUMMY_BYTES32[1] })
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.hasEmptyAccount(
DUMMY_ACCOUNTS[0].address
) )
).to.not.be.reverted ).to.equal(true)
})
}) })
it('should be able to overwrite a storage slot for a given contract', async () => { describe('when the account has a different non-zero codehash', () => {
await OVM_StateManager.putContractStorage( beforeEach(async () => {
await OVM_StateManager.putAccount(
DUMMY_ACCOUNTS[0].address, DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0], DUMMY_ACCOUNTS[0].data
DUMMY_BYTES32[1]
) )
})
await expect( it('should return false', async () => {
OVM_StateManager.putContractStorage( expect(
DUMMY_ACCOUNTS[0].address, await OVM_StateManager.callStatic.hasEmptyAccount(
DUMMY_BYTES32[0], DUMMY_ACCOUNTS[0].address
DUMMY_BYTES32[2] )
).to.equal(false)
})
})
describe('when the account does not exist', () => {
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.hasEmptyAccount(
DUMMY_ACCOUNTS[0].address
) )
).to.equal(false)
})
})
})
describe('setAccountNonce', () => {
it('should change the account nonce', async () => {
await expect(
OVM_StateManager.setAccountNonce(DUMMY_ACCOUNTS[0].address, 1234)
).to.not.be.reverted ).to.not.be.reverted
}) })
}) })
describe('getContractStorage', () => { describe('getAccountNonce', () => {
it('should be able to retrieve a storage slot for a given contract', async () => { describe('when the account exists', () => {
await OVM_StateManager.putContractStorage( beforeEach(async () => {
await OVM_StateManager.putAccount(
DUMMY_ACCOUNTS[0].address, DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0], DUMMY_ACCOUNTS[0].data
DUMMY_BYTES32[1]
) )
})
it('should return the current nonce', async () => {
expect( expect(
await OVM_StateManager.callStatic.getContractStorage( await OVM_StateManager.callStatic.getAccountNonce(
DUMMY_ACCOUNTS[0].address, DUMMY_ACCOUNTS[0].address
DUMMY_BYTES32[0]
) )
).to.equal(DUMMY_BYTES32[1]) ).to.equal(DUMMY_ACCOUNTS[0].data.nonce)
}) })
it('should be able to retrieve an overwritten storage slot for a given contract', async () => { describe('when the nonce has been modified', () => {
await OVM_StateManager.putContractStorage( beforeEach(async () => {
await OVM_StateManager.setAccountNonce(
DUMMY_ACCOUNTS[0].address, DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0], 1234
DUMMY_BYTES32[1]
) )
})
await OVM_StateManager.putContractStorage( it('should return the updated nonce', async () => {
expect(
await OVM_StateManager.callStatic.getAccountNonce(
DUMMY_ACCOUNTS[0].address
)
).to.equal(1234)
})
})
})
describe('when the account does not exist', () => {
it('should return zero', async () => {
expect(
await OVM_StateManager.callStatic.getAccountNonce(
DUMMY_ACCOUNTS[0].address
)
).to.equal(0)
})
})
})
describe('getAccountEthAddress', () => {
describe('when the account exists', () => {
beforeEach(async () => {
await OVM_StateManager.putAccount(
DUMMY_ACCOUNTS[0].address, DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0], DUMMY_ACCOUNTS[0].data
DUMMY_BYTES32[2]
) )
})
it('should return the account eth address', async () => {
expect( expect(
await OVM_StateManager.callStatic.getContractStorage( await OVM_StateManager.getAccountEthAddress(DUMMY_ACCOUNTS[0].address)
).to.equal(DUMMY_ACCOUNTS[0].data.ethAddress)
})
})
describe('when the account does not exist', () => {
it('should return the zero address', async () => {
expect(
await OVM_StateManager.getAccountEthAddress(DUMMY_ACCOUNTS[0].address)
).to.equal(ZERO_ADDRESS)
})
})
})
describe('initPendingAccount', () => {
it('should set the initial account values', async () => {
await expect(
OVM_StateManager.initPendingAccount(DUMMY_ACCOUNTS[0].address)
).to.not.be.reverted
expect(
_.toPlainObject(
await OVM_StateManager.callStatic.getAccount(
DUMMY_ACCOUNTS[0].address
)
)
).to.deep.include({
nonce: BigNumber.from(1),
codeHash: RLP_NULL_HASH,
isFresh: true,
})
})
})
describe('commitPendingAccount', () => {
it('should set the remaining account values', async () => {
await expect(
OVM_StateManager.commitPendingAccount(
DUMMY_ACCOUNTS[0].address, DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0] DUMMY_ACCOUNTS[0].data.ethAddress,
DUMMY_ACCOUNTS[0].data.codeHash
) )
).to.equal(DUMMY_BYTES32[2]) ).to.not.be.reverted
expect(
_.toPlainObject(
await OVM_StateManager.callStatic.getAccount(
DUMMY_ACCOUNTS[0].address
)
)
).to.deep.include({
ethAddress: DUMMY_ACCOUNTS[0].data.ethAddress,
codeHash: DUMMY_ACCOUNTS[0].data.codeHash,
})
})
})
describe('testAndSetAccountChanged', () => {
describe('when the account has not yet been changed', () => {
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetAccountChanged(
DUMMY_ACCOUNTS[0].address
)
).to.equal(false)
})
})
describe('when the account has been changed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetAccountChanged(
DUMMY_ACCOUNTS[0].address
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetAccountChanged(
DUMMY_ACCOUNTS[0].address
)
).to.equal(true)
})
})
})
describe('testAndSetAccountLoaded', () => {
describe('when the account has not yet been loaded', () => {
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetAccountLoaded(
DUMMY_ACCOUNTS[0].address
)
).to.equal(false)
})
})
describe('when the account has been loaded', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetAccountLoaded(
DUMMY_ACCOUNTS[0].address
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetAccountLoaded(
DUMMY_ACCOUNTS[0].address
)
).to.equal(true)
})
})
describe('when the account has been changed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetAccountChanged(
DUMMY_ACCOUNTS[0].address
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetAccountLoaded(
DUMMY_ACCOUNTS[0].address
)
).to.equal(true)
})
})
})
describe('commitAccount', () => {
describe('when the account has not been touched', () => {
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.commitAccount(
DUMMY_ACCOUNTS[0].address
)
).to.equal(false)
})
})
describe('when the account has been loaded but not changed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetAccountLoaded(
DUMMY_ACCOUNTS[0].address
)
})
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.commitAccount(
DUMMY_ACCOUNTS[0].address
)
).to.equal(false)
})
})
describe('when the account has been changed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetAccountChanged(
DUMMY_ACCOUNTS[0].address
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.commitAccount(
DUMMY_ACCOUNTS[0].address
)
).to.equal(true)
})
})
describe('when the account has already been committed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetAccountChanged(
DUMMY_ACCOUNTS[0].address
)
await OVM_StateManager.commitAccount(DUMMY_ACCOUNTS[0].address)
})
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.commitAccount(
DUMMY_ACCOUNTS[0].address
)
).to.equal(false)
})
})
})
describe('incrementTotalUncommittedAccounts', () => {
it('should update the total uncommitted accounts', async () => {
await expect(OVM_StateManager.incrementTotalUncommittedAccounts()).to.not
.be.reverted
})
})
describe('getTotalUncommittedAccounts', () => {
describe('when the total count has not been changed', () => {
it('should return zero', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedAccounts()
).to.equal(0)
})
})
describe('when the count has been incremented', () => {
describe('one time', () => {
beforeEach(async () => {
await OVM_StateManager.incrementTotalUncommittedAccounts()
})
it('should return one', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedAccounts()
).to.equal(1)
})
describe('when an account has been committed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetAccountChanged(
DUMMY_ACCOUNTS[0].address
)
await OVM_StateManager.commitAccount(DUMMY_ACCOUNTS[0].address)
})
it('should return zero', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedAccounts()
).to.equal(0)
})
})
})
describe('ten times', () => {
beforeEach(async () => {
for (let i = 0; i < 10; i++) {
await OVM_StateManager.incrementTotalUncommittedAccounts()
}
})
it('should return one', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedAccounts()
).to.equal(10)
})
describe('when an account has been committed', () => {
describe('one time', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetAccountChanged(
DUMMY_ACCOUNTS[0].address
)
await OVM_StateManager.commitAccount(DUMMY_ACCOUNTS[0].address)
})
it('should return nine', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedAccounts()
).to.equal(9)
})
})
})
})
})
})
describe('putContractStorage', () => {
it('should be able to insert a storage slot for a given contract', async () => {
await expect(
OVM_StateManager.putContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0],
DUMMY_BYTES32[1]
)
).to.not.be.reverted
})
it('should be able to overwrite a storage slot for a given contract', async () => {
await OVM_StateManager.putContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0],
DUMMY_BYTES32[1]
)
await expect(
OVM_StateManager.putContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0],
DUMMY_BYTES32[2]
)
).to.not.be.reverted
})
})
describe('getContractStorage', () => {
it('should be able to retrieve a storage slot for a given contract', async () => {
await OVM_StateManager.putContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0],
DUMMY_BYTES32[1]
)
expect(
await OVM_StateManager.callStatic.getContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(DUMMY_BYTES32[1])
})
it('should be able to retrieve an overwritten storage slot for a given contract', async () => {
await OVM_StateManager.putContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0],
DUMMY_BYTES32[1]
)
await OVM_StateManager.putContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0],
DUMMY_BYTES32[2]
)
expect(
await OVM_StateManager.callStatic.getContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(DUMMY_BYTES32[2])
})
})
describe('hasContractStorage', () => {
describe('when the storage slot has not been verified', () => {
it('should return false', async () => {
expect(
await OVM_StateManager.hasContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(false)
})
})
describe('when the storage slot has been verified', () => {
beforeEach(async () => {
await OVM_StateManager.putContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0],
DUMMY_BYTES32[1]
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.hasContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(true)
})
})
describe('when the account is newly created', () => {
beforeEach(async () => {
await OVM_StateManager.initPendingAccount(DUMMY_ACCOUNTS[0].address)
})
it('should return true for any slot', async () => {
for (const DUMMY_KEY of DUMMY_BYTES32) {
expect(
await OVM_StateManager.hasContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_KEY
)
).to.equal(true)
}
})
})
})
describe('testAndSetContractStorageChanged', () => {
describe('when the storage slot has not been touched', () => {
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(false)
})
})
describe('when the storage slot has been loaded but not changed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageLoaded(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(false)
})
})
describe('when the storage slot has been changed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(true)
})
})
describe('when the storage slot has been committed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
await OVM_StateManager.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(true)
})
})
})
describe('testAndSetContractStorageLoaded', () => {
describe('when the storage slot has not been touched', () => {
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetContractStorageLoaded(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(false)
})
})
describe('when the storage slot has already been loaded', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageLoaded(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetContractStorageLoaded(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(true)
})
})
describe('when the storage slot has already been changed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetContractStorageLoaded(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(true)
})
})
describe('when the storage slot has been committed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
await OVM_StateManager.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.testAndSetContractStorageLoaded(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(true)
})
})
})
describe('commitContractStorage', () => {
describe('when the storage slot has not been touched', () => {
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(false)
})
})
describe('when the storage slot has been loaded', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageLoaded(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(false)
})
})
describe('when the storage slot has been changed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return true', async () => {
expect(
await OVM_StateManager.callStatic.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(true)
})
})
describe('when the storage slot has been committed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
await OVM_StateManager.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return false', async () => {
expect(
await OVM_StateManager.callStatic.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
).to.equal(false)
})
})
})
describe('incrementTotalUncommittedContractStorage', () => {
it('should update the total uncommitted storage slots', async () => {
await expect(OVM_StateManager.incrementTotalUncommittedContractStorage())
.to.not.be.reverted
})
})
describe('getTotalUncommittedContractStorage', () => {
describe('when the total count has not been changed', () => {
it('should return zero', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedContractStorage()
).to.equal(0)
})
})
describe('when the count has been incremented', () => {
describe('one time', () => {
beforeEach(async () => {
await OVM_StateManager.incrementTotalUncommittedContractStorage()
})
it('should return one', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedContractStorage()
).to.equal(1)
})
describe('when a storage slot has been committed', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
await OVM_StateManager.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return zero', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedContractStorage()
).to.equal(0)
})
})
})
describe('ten times', () => {
beforeEach(async () => {
for (let i = 0; i < 10; i++) {
await OVM_StateManager.incrementTotalUncommittedContractStorage()
}
})
it('should return ten', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedContractStorage()
).to.equal(10)
})
describe('when a storage slot has been committed', () => {
describe('one time', () => {
beforeEach(async () => {
await OVM_StateManager.testAndSetContractStorageChanged(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
await OVM_StateManager.commitContractStorage(
DUMMY_ACCOUNTS[0].address,
DUMMY_BYTES32[0]
)
})
it('should return nine', async () => {
expect(
await OVM_StateManager.callStatic.getTotalUncommittedContractStorage()
).to.equal(9)
})
})
})
})
}) })
}) })
}) })
packages/contracts/test/contracts/OVM/queue/OVM_L1ToL2TransactionQueue.spec.ts
View file @ c7b37b40
...@@ -2,29 +2,39 @@ import { expect } from '../../../setup' ...@@ -2,29 +2,39 @@ import { expect } from '../../../setup'
/* External Imports */ /* External Imports */
import { ethers } from '@nomiclabs/buidler' import { ethers } from '@nomiclabs/buidler'
import { Contract, ContractFactory, Signer } from 'ethers' import { Contract, ContractFactory, Signer, BigNumber } from 'ethers'
import { keccak256 } from 'ethers/lib/utils'
import _ from 'lodash'
/* Internal Imports */ /* Internal Imports */
import { getProxyManager, ZERO_ADDRESS, NULL_BYTES32 } from '../../../helpers' import {
ZERO_ADDRESS,
NON_ZERO_ADDRESS,
DUMMY_BYTES32,
remove0x,
getBlockTime,
makeAddressManager,
} from '../../../helpers'
const parseQueueElement = (result: any[]): any => { const calcBatchRoot = (element: any): string => {
return { return keccak256(
timestamp: result[0].toNumber(), element.target +
batchRoot: result[1], remove0x(BigNumber.from(element.gasLimit).toHexString()).padStart(
isL1ToL2Batch: result[2], 64,
} '0'
) +
remove0x(element.data)
)
} }
const makeQueueElements = (count: number): any => { const makeQueueElements = (count: number): any => {
const elements = [] return [...Array(count)].map((el, idx) => {
for (let i = 0; i < count; i++) { return {
elements.push({ target: NON_ZERO_ADDRESS,
timestamp: Date.now(), gasLimit: idx,
batchRoot: NULL_BYTES32, data: DUMMY_BYTES32[0],
isL1ToL2Batch: false,
})
} }
return elements })
} }
describe('OVM_L1ToL2TransactionQueue', () => { describe('OVM_L1ToL2TransactionQueue', () => {
...@@ -33,9 +43,9 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -33,9 +43,9 @@ describe('OVM_L1ToL2TransactionQueue', () => {
;[signer] = await ethers.getSigners() ;[signer] = await ethers.getSigners()
}) })
let Proxy_Manager: Contract let AddressManager: Contract
before(async () => { before(async () => {
Proxy_Manager = await getProxyManager() AddressManager = await makeAddressManager()
}) })
let Factory__OVM_L1ToL2TransactionQueue: ContractFactory let Factory__OVM_L1ToL2TransactionQueue: ContractFactory
...@@ -48,22 +58,31 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -48,22 +58,31 @@ describe('OVM_L1ToL2TransactionQueue', () => {
let OVM_L1ToL2TransactionQueue: Contract let OVM_L1ToL2TransactionQueue: Contract
beforeEach(async () => { beforeEach(async () => {
OVM_L1ToL2TransactionQueue = await Factory__OVM_L1ToL2TransactionQueue.deploy( OVM_L1ToL2TransactionQueue = await Factory__OVM_L1ToL2TransactionQueue.deploy(
Proxy_Manager.address AddressManager.address
) )
}) })
describe('enqueue()', () => { describe('enqueue()', () => {
it('should allow users to enqueue an element', async () => { it('should allow users to enqueue an element', async () => {
const [element] = makeQueueElements(1) const [element] = makeQueueElements(1)
await expect(OVM_L1ToL2TransactionQueue.enqueue(element)).to.not.be await expect(
.reverted OVM_L1ToL2TransactionQueue.enqueue(
element.target,
element.gasLimit,
element.data
)
).to.not.be.reverted
}) })
it('should allow users to enqueue more than one element', async () => { it('should allow users to enqueue more than one element', async () => {
const elements = makeQueueElements(10) for (const element of makeQueueElements(10)) {
for (const element of elements) { await expect(
await expect(OVM_L1ToL2TransactionQueue.enqueue(element)).to.not.be OVM_L1ToL2TransactionQueue.enqueue(
.reverted element.target,
element.gasLimit,
element.data
)
).to.not.be.reverted
} }
}) })
}) })
...@@ -71,7 +90,7 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -71,7 +90,7 @@ describe('OVM_L1ToL2TransactionQueue', () => {
describe('dequeue()', () => { describe('dequeue()', () => {
describe('when the sender is not the OVM_CanonicalTransactionChain', () => { describe('when the sender is not the OVM_CanonicalTransactionChain', () => {
before(async () => { before(async () => {
await Proxy_Manager.setProxy( await AddressManager.setAddress(
'OVM_CanonicalTransactionChain', 'OVM_CanonicalTransactionChain',
ZERO_ADDRESS ZERO_ADDRESS
) )
...@@ -86,7 +105,7 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -86,7 +105,7 @@ describe('OVM_L1ToL2TransactionQueue', () => {
describe('when the sender is the OVM_CanonicalTransactionChain', () => { describe('when the sender is the OVM_CanonicalTransactionChain', () => {
before(async () => { before(async () => {
await Proxy_Manager.setProxy( await AddressManager.setAddress(
'OVM_CanonicalTransactionChain', 'OVM_CanonicalTransactionChain',
await signer.getAddress() await signer.getAddress()
) )
...@@ -100,15 +119,25 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -100,15 +119,25 @@ describe('OVM_L1ToL2TransactionQueue', () => {
it('should allow users to dequeue an element', async () => { it('should allow users to dequeue an element', async () => {
const [element] = makeQueueElements(1) const [element] = makeQueueElements(1)
await OVM_L1ToL2TransactionQueue.enqueue(element) await OVM_L1ToL2TransactionQueue.enqueue(
element.target,
element.gasLimit,
element.data
)
await expect(OVM_L1ToL2TransactionQueue.dequeue()).to.not.be.reverted await expect(OVM_L1ToL2TransactionQueue.dequeue()).to.not.be.reverted
}) })
it('should allow users to dequeue more than one element', async () => { it('should allow users to dequeue more than one element', async () => {
const elements = makeQueueElements(10) const elements = makeQueueElements(10)
for (const element of elements) { for (const element of elements) {
await OVM_L1ToL2TransactionQueue.enqueue(element) await OVM_L1ToL2TransactionQueue.enqueue(
element.target,
element.gasLimit,
element.data
)
} }
for (const element of elements) { for (const element of elements) {
await expect(OVM_L1ToL2TransactionQueue.dequeue()).to.not.be.reverted await expect(OVM_L1ToL2TransactionQueue.dequeue()).to.not.be.reverted
} }
...@@ -118,7 +147,7 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -118,7 +147,7 @@ describe('OVM_L1ToL2TransactionQueue', () => {
describe('size()', () => { describe('size()', () => {
before(async () => { before(async () => {
await Proxy_Manager.setProxy( await AddressManager.setAddress(
'OVM_CanonicalTransactionChain', 'OVM_CanonicalTransactionChain',
await signer.getAddress() await signer.getAddress()
) )
...@@ -132,7 +161,13 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -132,7 +161,13 @@ describe('OVM_L1ToL2TransactionQueue', () => {
it('should increase when new elements are enqueued', async () => { it('should increase when new elements are enqueued', async () => {
const elements = makeQueueElements(10) const elements = makeQueueElements(10)
for (let i = 0; i < elements.length; i++) { for (let i = 0; i < elements.length; i++) {
await OVM_L1ToL2TransactionQueue.enqueue(elements[i]) const element = elements[i]
await OVM_L1ToL2TransactionQueue.enqueue(
element.target,
element.gasLimit,
element.data
)
const size = await OVM_L1ToL2TransactionQueue.size() const size = await OVM_L1ToL2TransactionQueue.size()
expect(size).to.equal(i + 1) expect(size).to.equal(i + 1)
} }
...@@ -140,9 +175,15 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -140,9 +175,15 @@ describe('OVM_L1ToL2TransactionQueue', () => {
it('should decrease when elements are dequeued', async () => { it('should decrease when elements are dequeued', async () => {
const elements = makeQueueElements(10) const elements = makeQueueElements(10)
for (const element of elements) { for (const element of elements) {
await OVM_L1ToL2TransactionQueue.enqueue(element) await OVM_L1ToL2TransactionQueue.enqueue(
element.target,
element.gasLimit,
element.data
)
} }
for (let i = 0; i < elements.length; i++) { for (let i = 0; i < elements.length; i++) {
await OVM_L1ToL2TransactionQueue.dequeue() await OVM_L1ToL2TransactionQueue.dequeue()
const size = await OVM_L1ToL2TransactionQueue.size() const size = await OVM_L1ToL2TransactionQueue.size()
...@@ -153,7 +194,7 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -153,7 +194,7 @@ describe('OVM_L1ToL2TransactionQueue', () => {
describe('peek()', () => { describe('peek()', () => {
before(async () => { before(async () => {
await Proxy_Manager.setProxy( await AddressManager.setAddress(
'OVM_CanonicalTransactionChain', 'OVM_CanonicalTransactionChain',
await signer.getAddress() await signer.getAddress()
) )
...@@ -167,28 +208,75 @@ describe('OVM_L1ToL2TransactionQueue', () => { ...@@ -167,28 +208,75 @@ describe('OVM_L1ToL2TransactionQueue', () => {
it('should return the front element if only one exists', async () => { it('should return the front element if only one exists', async () => {
const [element] = makeQueueElements(1) const [element] = makeQueueElements(1)
await OVM_L1ToL2TransactionQueue.enqueue(element)
const front = await OVM_L1ToL2TransactionQueue.peek() const result = await OVM_L1ToL2TransactionQueue.enqueue(
expect(parseQueueElement(front)).to.deep.equal(element) element.target,
element.gasLimit,
element.data
)
const timestamp = BigNumber.from(
await getBlockTime(ethers.provider, result.blockNumber)
)
expect(
_.toPlainObject(await OVM_L1ToL2TransactionQueue.peek())
).to.deep.include({
timestamp,
batchRoot: calcBatchRoot(element),
isL1ToL2Batch: true,
})
}) })
it('should return the front if more than one exists', async () => { it('should return the front if more than one exists', async () => {
const elements = makeQueueElements(10) const elements = makeQueueElements(10)
for (const element of elements) { const result = await OVM_L1ToL2TransactionQueue.enqueue(
await OVM_L1ToL2TransactionQueue.enqueue(element) elements[0].target,
const front = await OVM_L1ToL2TransactionQueue.peek() elements[0].gasLimit,
expect(parseQueueElement(front)).to.deep.equal(elements[0]) elements[0].data
)
const timestamp = BigNumber.from(
await getBlockTime(ethers.provider, result.blockNumber)
)
for (const element of elements.slice(1)) {
expect(
_.toPlainObject(await OVM_L1ToL2TransactionQueue.peek())
).to.deep.include({
timestamp,
batchRoot: calcBatchRoot(elements[0]),
isL1ToL2Batch: true,
})
} }
}) })
it('should return the new front when elements are dequeued', async () => { it('should return the new front when elements are dequeued', async () => {
const elements = makeQueueElements(10) const elements = makeQueueElements(10)
const timestamps: BigNumber[] = []
for (const element of elements) { for (const element of elements) {
await OVM_L1ToL2TransactionQueue.enqueue(elements) const result = await OVM_L1ToL2TransactionQueue.enqueue(
element.target,
element.gasLimit,
element.data
)
timestamps.push(
BigNumber.from(
await getBlockTime(ethers.provider, result.blockNumber)
)
)
} }
for (let i = 0; i < elements.length - 1; i++) { for (let i = 0; i < elements.length - 1; i++) {
const front = await OVM_L1ToL2TransactionQueue.peek() expect(
expect(parseQueueElement(front)).to.deep.equal(elements[i + 1]) _.toPlainObject(await OVM_L1ToL2TransactionQueue.peek())
).to.deep.include({
timestamp: timestamps[i],
batchRoot: calcBatchRoot(elements[i]),
isL1ToL2Batch: true,
})
await OVM_L1ToL2TransactionQueue.dequeue() await OVM_L1ToL2TransactionQueue.dequeue()
} }
}) })
......
packages/contracts/test/contracts/OVM/verification/OVM_FraudVerifier.spec.ts
View file @ c7b37b40
...@@ -5,6 +5,8 @@ import { ethers } from '@nomiclabs/buidler' ...@@ -5,6 +5,8 @@ import { ethers } from '@nomiclabs/buidler'
import { ContractFactory, Contract, Signer, BigNumber } from 'ethers' import { ContractFactory, Contract, Signer, BigNumber } from 'ethers'
/* Internal Imports */ /* Internal Imports */
/*
import { import {
getProxyManager, getProxyManager,
getMockContract, getMockContract,
...@@ -370,3 +372,4 @@ describe('OVM_FraudVerifier', () => { ...@@ -370,3 +372,4 @@ describe('OVM_FraudVerifier', () => {
}) })
}) })
}) })
*/
packages/contracts/test/helpers/buidler/modify-compiler.ts deleted 100644 → 0
View file @ 6e1dbfe0
/* External Imports */
import fsExtra from 'fs-extra'
import { internalTask } from '@nomiclabs/buidler/config'
import { pluralize } from '@nomiclabs/buidler/internal/util/strings'
import {
getArtifactFromContractOutput,
saveArtifact,
} from '@nomiclabs/buidler/internal/artifacts'
import {
TASK_COMPILE_GET_COMPILER_INPUT,
TASK_BUILD_ARTIFACTS,
TASK_COMPILE_GET_SOURCE_PATHS,
TASK_COMPILE_CHECK_CACHE,
TASK_COMPILE_COMPILE,
} from '@nomiclabs/buidler/builtin-tasks/task-names'
internalTask(
TASK_COMPILE_GET_COMPILER_INPUT,
async (_, { config, run }, runSuper) => {
const input = await runSuper()
// Insert the "storageLayout" input option.
input.settings.outputSelection['*']['*'].push('storageLayout')
return input
}
)
internalTask(TASK_BUILD_ARTIFACTS).setAction(
async ({ force }, { config, run }) => {
const sources = await run(TASK_COMPILE_GET_SOURCE_PATHS)
if (sources.length === 0) {
console.log('No Solidity source file available.')
return
}
const isCached: boolean = await run(TASK_COMPILE_CHECK_CACHE, { force })
if (isCached) {
console.log(
'All contracts have already been compiled, skipping compilation.'
)
return
}
const compilationOutput = await run(TASK_COMPILE_COMPILE)
if (compilationOutput === undefined) {
return
}
await fsExtra.ensureDir(config.paths.artifacts)
let numberOfContracts = 0
for (const file of Object.values<any>(compilationOutput.contracts)) {
for (const [contractName, contractOutput] of Object.entries(file)) {
const artifact: any = getArtifactFromContractOutput(
contractName,
contractOutput
)
numberOfContracts += 1
// Only difference here, set the "storageLayout" field of the artifact.
artifact.storageLayout = (contractOutput as any).storageLayout
await saveArtifact(config.paths.artifacts, artifact)
}
}
console.log(
'Compiled',
numberOfContracts,
pluralize(numberOfContracts, 'contract'),
'successfully'
)
}
)
packages/contracts/test/helpers/constants.ts
View file @ c7b37b40
...@@ -37,7 +37,8 @@ export const NUISANCE_GAS_COSTS = { ...@@ -37,7 +37,8 @@ export const NUISANCE_GAS_COSTS = {
// TODO: get this exported/imported somehow in a way that we can do math on it. unfortunately using require('.....artifacts/contract.json') is erroring... // TODO: get this exported/imported somehow in a way that we can do math on it. unfortunately using require('.....artifacts/contract.json') is erroring...
export const Helper_TestRunner_BYTELEN = 3654 export const Helper_TestRunner_BYTELEN = 3654
export const STORAGE_XOR = '0xfeedfacecafebeeffeedfacecafebeeffeedfacecafebeeffeedfacecafebeef' export const STORAGE_XOR =
'0xfeedfacecafebeeffeedfacecafebeeffeedfacecafebeeffeedfacecafebeef'
export const getStorageXOR = (key: string): string => { export const getStorageXOR = (key: string): string => {
return toHexString(xor(fromHexString(key), fromHexString(STORAGE_XOR))) return toHexString(xor(fromHexString(key), fromHexString(STORAGE_XOR)))
} }
packages/contracts/test/helpers/dummy/accounts.ts
View file @ c7b37b40
/* External Imports */
import { BigNumber } from 'ethers'
/* Internal Imports */ /* Internal Imports */
import { DUMMY_BYTES32 } from './bytes32' import { DUMMY_BYTES32 } from './bytes32'
import { ZERO_ADDRESS, NON_ZERO_ADDRESS } from '../constants' import { ZERO_ADDRESS, NON_ZERO_ADDRESS } from '../constants'
...@@ -11,8 +14,8 @@ export const DUMMY_ACCOUNTS: Array<{ ...@@ -11,8 +14,8 @@ export const DUMMY_ACCOUNTS: Array<{
{ {
address: makeAddress('12'), address: makeAddress('12'),
data: { data: {
nonce: 123, nonce: BigNumber.from(123),
balance: 456, balance: BigNumber.from(456),
storageRoot: DUMMY_BYTES32[0], storageRoot: DUMMY_BYTES32[0],
codeHash: DUMMY_BYTES32[1], codeHash: DUMMY_BYTES32[1],
ethAddress: ZERO_ADDRESS, ethAddress: ZERO_ADDRESS,
...@@ -21,8 +24,8 @@ export const DUMMY_ACCOUNTS: Array<{ ...@@ -21,8 +24,8 @@ export const DUMMY_ACCOUNTS: Array<{
{ {
address: makeAddress('21'), address: makeAddress('21'),
data: { data: {
nonce: 321, nonce: BigNumber.from(321),
balance: 654, balance: BigNumber.from(654),
storageRoot: DUMMY_BYTES32[2], storageRoot: DUMMY_BYTES32[2],
codeHash: DUMMY_BYTES32[3], codeHash: DUMMY_BYTES32[3],
ethAddress: NON_ZERO_ADDRESS, ethAddress: NON_ZERO_ADDRESS,
......
packages/contracts/test/helpers/index.ts
View file @ c7b37b40
export * from './dummy' export * from './dummy'
export * from './types' export * from './types'
export * from './constants' export * from './constants'
export * from './proxy' export * from './resolver'
export * from './mocks'
export * from './utils' export * from './utils'
export * from './codec' export * from './codec'
export * from './test-runner' export * from './test-runner'
export * from './storage'
export * from './solidity'
packages/contracts/test/helpers/mocks/index.ts deleted 100644 → 0
View file @ 6e1dbfe0
export * from './mock-contract.types'
export * from './mock-generation'
packages/contracts/test/helpers/mocks/mock-binding.ts deleted 100644 → 0
View file @ 6e1dbfe0
/* External Imports */
import bre from '@nomiclabs/buidler'
import { ethers, Contract, ContractFactory } from 'ethers'
/* Internal Imports */
import { toHexString, fromHexString } from '../utils'
import { MockContract, MockContractFunction } from './mock-contract.types'
/**
* Binds logic to the buidler node that checks for calls to mock contracts and
* replaces return values. Runs once as to avoid repeatedly hijacking functions
* for each new mock contract.
*/
export const bindMockWatcherToVM = (): void => {
const node = bre.network.provider['_node' as any]
// No need to bind here if we've already done so.
if (node.__calls) {
return
}
const vmTracer = node['_vmTracer' as any]
const vm = node['_vm' as any]
// Set up some things we'll need for later.
let txid: string
const messages: Array<{
address: string
sighash: string
calldata: string
}> = []
node.__calls = {}
node.__contracts = {}
// Modify the vm.runTx function to capture an ID for each transaction.
const originalRunTx = vm.runTx.bind(vm)
function modifiedRunTx(opts: any): Promise<any> {
// Buidler runs transactions multiple times (e.g., for gas estimation).
// Here we're computing a unique ID for each transaction (based on sender,
// nonce, and transaction data) so that we don't log calls multiple times.
txid = ethers.utils.keccak256(
'0x' +
opts.tx._from.toString('hex') +
opts.tx.nonce.toString('hex') +
opts.tx.data.toString('hex')
)
// Wipe the calls for this txid to avoid duplicate results.
node.__calls[txid] = {}
return originalRunTx(opts)
}
vm['runTx' as any] = modifiedRunTx.bind(vm)
// Modify the pre-message handler to capture calldata.
const originalBeforeMessageHandler = vmTracer['_beforeMessageHandler' as any]
function modifiedBeforeMessageHandler(message: any, next: any) {
// We only care about capturing if we're sending to one of our mocks.
const address = message.to
? toHexString(message.to).toLowerCase()
: undefined
const contract = node.__contracts[address]
if (address && contract) {
const calldata = toHexString(message.data.slice(4))
let sighash = toHexString(message.data.slice(0, 4))
if (contract.__sigmap) {
sighash = contract.__sigmap[sighash]
message.data.write(sighash.slice(2), 0, 4, 'hex')
}
// Store the message for use in the post-message handler.
messages.push({
address,
sighash,
calldata,
})
// Basic existence checks.
if (!node.__calls[txid][address]) {
node.__calls[txid][address] = {}
}
if (!node.__calls[txid][address][sighash]) {
node.__calls[txid][address][sighash] = []
}
// Add the data to the per-sighash array.
node.__calls[txid][address][sighash].push(toHexString(message.data))
}
originalBeforeMessageHandler(message, next)
}
// Modify the post-message handler to insert the correct return data.
const originalAfterMessageHandler = vmTracer['_afterMessageHandler' as any]
async function modifiedAfterMessageHandler(result: any, next: any) {
// We don't need to do anything if we haven't stored any mock messages.
if (messages.length > 0) {
// We need to look at the messages backwards since the first result will
// correspond to the last message on the stack.
const message = messages.pop()
const contract: Contract = node.__contracts[message.address]
const fn: MockContractFunction = contract.__fns[message.sighash]
// Compute our return values.
const inputParams = contract.__spec
? contract.__spec.interface.decodeFunctionData(
fn.functionName,
contract.__spec.interface.getSighash(fn.functionName) +
message.calldata.slice(2)
)
: ethers.utils.defaultAbiCoder.decode(fn.inputTypes, message.calldata)
const returnValues = Array.isArray(fn.returnValues)
? fn.returnValues
: await fn.returnValues(...inputParams)
const returnBuffer = fromHexString(
contract.__spec
? contract.__spec.interface.encodeFunctionResult(
fn.functionName,
returnValues
)
: ethers.utils.defaultAbiCoder.encode(fn.outputTypes, returnValues)
)
// Set the return value to match our computed value.
result.execResult.returnValue = returnBuffer
}
originalAfterMessageHandler(result, next)
}
// Disable tracing to remove the old handlers before adding new ones.
vmTracer.disableTracing()
vmTracer['_beforeMessageHandler' as any] = modifiedBeforeMessageHandler.bind(
vmTracer
)
vmTracer['_afterMessageHandler' as any] = modifiedAfterMessageHandler.bind(
vmTracer
)
vmTracer.enableTracing()
}
/**
* Binds a mock contract to the VM and inserts necessary functions.
* @param mock Mock contract to bind.
* @param fns Contract functions associated with the mock.
*/
export const bindMockContractToVM = (
mock: MockContract,
fns: MockContractFunction[],
spec: MockContractFunction[] | Contract | ContractFactory
): void => {
const node = bre.network.provider['_node' as any]
node.__contracts[mock.address.toLowerCase()] = mock
const getCalls = (functionName: string): string[] => {
const calls: {
[sighash: string]: string[]
} = {}
for (const txid of Object.keys(node.__calls)) {
for (const address of Object.keys(node.__calls[txid])) {
if (address === mock.address.toLowerCase()) {
for (const sighash of Object.keys(node.__calls[txid][address])) {
const txcalls = node.__calls[txid][address][sighash]
calls[sighash] = calls[sighash]
? calls[sighash].concat(txcalls)
: txcalls
}
}
}
}
const sig = mock.interface.getSighash(functionName)
return calls[sig] || []
}
if (!Array.isArray(spec)) {
;(mock as any).__spec = spec
;(mock as any).__sigmap = Object.keys(mock.interface.functions).reduce(
(sigmap, fn) => {
fn = fn.split('(')[0]
sigmap[spec.interface.getSighash(fn)] = mock.interface.getSighash(fn)
return sigmap
},
{}
)
}
;(mock as any).getCallCount = (functionName: string): number => {
return getCalls(functionName).length
}
;(mock as any).getCallData = (
functionName: string,
callIndex: number
): any[] => {
const calls = getCalls(functionName)
if (calls.length <= callIndex) {
throw new Error('Provided function call index does not exist.')
}
const iface = mock.__spec ? mock.__spec.interface : mock.interface
const calldata = iface.getSighash(functionName) + calls[callIndex].slice(10)
return iface.decodeFunctionData(functionName, calldata).map((element) => {
return element
})
}
;(mock as any).setReturnValues = (
functionName: string,
returnValues: any[] | ((...params: any[]) => any[])
): void => {
mock.__fns[
mock.interface.getSighash(functionName)
].returnValues = returnValues
}
;(mock as any).__fns = fns.reduce((fnmap, fn) => {
fnmap[mock.interface.getSighash(fn.functionName)] = fn
return fnmap
}, {})
}
packages/contracts/test/helpers/mocks/mock-contract.types.ts deleted 100644 → 0
View file @ 6e1dbfe0
/* External Imports */
import { Contract } from 'ethers'
export interface MockContractFunction {
functionName: string
inputTypes?: string[]
outputTypes?: string[]
returnValues?: any[] | ((...params: any[]) => any[] | Promise<any>)
}
export interface MockContract extends Contract {
getCallCount: (functionName: string) => number
getCallData: (functionName: string, callIndex: number) => any[]
setReturnValues: (
functionName: string,
returnValues: any[] | ((...params: any[]) => any[])
) => void
__fns: {
[sighash: string]: MockContractFunction
}
}
packages/contracts/test/helpers/mocks/mock-generation.ts deleted 100644 → 0
View file @ 6e1dbfe0
/* External Imports */
import { ethers } from '@nomiclabs/buidler'
import { Signer, Contract, ContractFactory } from 'ethers'
import { FunctionFragment, ParamType } from 'ethers/lib/utils'
/* Internal Imports */
import { MockContract, MockContractFunction } from './mock-contract.types'
import { bindMockContractToVM, bindMockWatcherToVM } from './mock-binding'
import { SolidityCompiler, getDefaultCompiler, compile } from '../solidity'
/**
* Generates contract code for a mock contract.
* @param fns Mock contract function definitions.
* @param contractName Name for the contract.
* @param compilerVersion Compiler version being used.
* @returns Contract code.
*/
const getSolidityMockContractCode = (
fns: MockContractFunction[],
contractName: string,
compilerVersion: string
): string => {
return `
pragma solidity ${compilerVersion};
contract ${contractName} {
${fns
.map((fn) => {
return `
function ${fn.functionName}(${fn.inputTypes
.map((inputType, idx) => {
return `${inputType} _${idx}`
})
.join(', ')})
public
{
return;
}
`
})
.join('\n')}
}
`
}
/**
* Checks that a mock contract function definition is valid.
* @param fn Mock contract function definition.
* @returns Whether or not the function is valid.
*/
const isValidMockContractFunction = (fn: MockContractFunction): boolean => {
return (
fn.inputTypes &&
fn.outputTypes &&
fn.returnValues &&
(!Array.isArray(fn.returnValues) ||
fn.outputTypes.length === fn.returnValues.length)
)
}
/**
* Basic sanitization for mock function definitions
* @param fn Mock contract function definition to sanitize.
* @returns Sanitized definition.
*/
export const sanitizeMockContractFunction = (
fn: MockContractFunction
): MockContractFunction => {
const sanitized = {
functionName: fn.functionName,
inputTypes: fn.inputTypes || [],
outputTypes: fn.outputTypes || [],
returnValues: fn.returnValues || [],
}
if (!isValidMockContractFunction(sanitized)) {
throw new Error(
'Provided MockContract function is invalid. Please check your mock definition.'
)
}
return sanitized
}
/**
* Basic sanitization for mock function definitions
* @param fns Mock contract function definitions to sanitize.
* @returns Sanitized definitions.
*/
const sanitizeMockContractFunctions = (
fns: MockContractFunction[]
): MockContractFunction[] => {
return fns.map((fn) => {
return sanitizeMockContractFunction(fn)
})
}
/**
* Gets mock return values for a set of output types.
* @param outputTypes Output types as ethers param types.
* @returns Mock return values.
*/
const getMockReturnValues = (outputTypes: ParamType[]): string[] => {
return outputTypes.map((outputType) => {
return outputType.type === outputType.baseType
? '0x' + '00'.repeat(32)
: '0x' + '00'.repeat(64)
})
}
/**
* Converts an ethers function fragment to a mock function.
* @param fn Function fragment to convert.
* @returns Generated mock function.
*/
const getMockFunctionFromFragment = (
fn: FunctionFragment
): MockContractFunction => {
return {
functionName: fn.name,
inputTypes: [],
outputTypes: [],
returnValues: getMockReturnValues(fn.outputs),
}
}
/**
* Generates mock functions from a contract spec.
* @param spec Contract or factory used as the spec.
* @returns Array of mock functions.
*/
const getFnsFromContractSpec = (
spec: Contract | ContractFactory
): MockContractFunction[] => {
return Object.values(spec.interface.functions)
.filter((fn) => {
return fn.type === 'function'
})
.map((fn) => {
return getMockFunctionFromFragment(fn)
})
}
/**
* Generates a mock contract for testing.
* @param spec Mock contract function definitions or contract to base on.
* @param signer Signer to use to deploy the mock.
* @param compiler Optional compiler instance to use.
* @returns Generated mock contract instance.
*/
export const getMockContract = async (
spec: MockContractFunction[] | Contract | ContractFactory | string,
signer?: Signer,
compiler?: SolidityCompiler
): Promise<MockContract> => {
if (typeof spec === 'string') {
spec = await ethers.getContractFactory(spec)
}
if (!Array.isArray(spec)) {
signer = signer || spec.signer
}
if (!signer) {
throw new Error('You must provide a signer.')
}
compiler = compiler || (await getDefaultCompiler())
const fns = Array.isArray(spec)
? sanitizeMockContractFunctions(spec)
: getFnsFromContractSpec(spec)
const contractName = 'MockContract'
const contractPath = contractName + '.sol'
const contractCode = getSolidityMockContractCode(
fns,
contractName,
'^' + compiler.version().split('+')[0]
)
const compilerOutput = await compile(
[
{
path: contractPath,
content: contractCode,
},
],
compiler
)
const MockContractJSON = compilerOutput.contracts[contractPath][contractName]
const MockContractFactory = new ethers.ContractFactory(
MockContractJSON.abi,
MockContractJSON.evm.bytecode.object,
signer
)
const originalDefinePropertyFn = Object.defineProperty
Object.defineProperty = (object: any, name: string, props: any): void => {
if (props.writable === false) {
props.writable = true
}
originalDefinePropertyFn(object, name, props)
}
const mock = (await MockContractFactory.deploy()) as MockContract
Object.defineProperty = originalDefinePropertyFn
bindMockWatcherToVM()
bindMockContractToVM(mock, fns, spec)
return mock
}
packages/contracts/test/helpers/proxy/proxy-manager.ts deleted 100644 → 0
View file @ 6e1dbfe0
/* External Imports */
import { ethers } from '@nomiclabs/buidler'
import { Contract } from 'ethers'
export const makeProxies = async (
Proxy_Manager: Contract,
names: string[]
): Promise<void> => {
for (const name of names) {
if (await Proxy_Manager['hasProxy(string)'](name)) {
continue
}
const Factory__Proxy_Forwarder = await ethers.getContractFactory(
'Proxy_Forwarder'
)
const Proxy_Forwarder = await Factory__Proxy_Forwarder.deploy(
Proxy_Manager.address
)
await Proxy_Manager.setProxy(name, Proxy_Forwarder.address)
}
}
export const setProxyTarget = async (
Proxy_Manager: Contract,
name: string,
target: Contract
): Promise<void> => {
await makeProxies(Proxy_Manager, [name])
await Proxy_Manager.setTarget(name, target.address)
}
export const getProxyManager = async (): Promise<Contract> => {
return (await ethers.getContractFactory('Proxy_Manager')).deploy()
}
packages/contracts/test/helpers/resolver/address-manager.ts 0 → 100644
View file @ c7b37b40
/* External Imports */
import { ethers } from '@nomiclabs/buidler'
import { Contract } from 'ethers'
export const setProxyTarget = async (
AddressManager: Contract,
name: string,
target: Contract
): Promise<void> => {
const SimpleProxy = await (
await ethers.getContractFactory('Helper_SimpleProxy')
).deploy(target.address)
await AddressManager.setAddress(name, SimpleProxy.address)
}
export const makeAddressManager = async (): Promise<Contract> => {
return (await ethers.getContractFactory('Lib_AddressManager')).deploy()
}
packages/contracts/test/helpers/solidity/compilation.ts deleted 100644 → 0
View file @ 6e1dbfe0
import * as path from 'path'
import bre from '@nomiclabs/buidler'
import { Compiler } from '@nomiclabs/buidler/internal/solidity/compiler'
export interface SolidityCompiler {
version: () => string
compile: any
}
export interface ContractSource {
path: string
content: string
}
export const getDefaultCompiler = async (): Promise<SolidityCompiler> => {
const compiler = new Compiler(
bre.config.solc.version,
path.join(bre.config.paths.cache, 'compilers')
)
return compiler.getSolc()
}
export const compile = async (
sources: ContractSource[],
compiler?: SolidityCompiler
): Promise<any> => {
compiler = compiler || (await getDefaultCompiler())
const compilerInput = {
language: 'Solidity',
sources: sources.reduce((parsed, source) => {
parsed[source.path] = {
content: source.content,
}
return parsed
}, {}),
settings: {
outputSelection: {
'*': {
'*': ['*'],
},
},
},
}
return JSON.parse(compiler.compile(JSON.stringify(compilerInput)))
}
packages/contracts/test/helpers/storage/contract-storage.ts deleted 100644 → 0
View file @ 6e1dbfe0
/* External Imports */
import bre, { ethers } from '@nomiclabs/buidler'
import { readArtifact } from '@nomiclabs/buidler/internal/artifacts'
import { Contract, BigNumber, ContractFactory } from 'ethers'
import { keccak256 } from 'ethers/lib/utils'
import _ from 'lodash'
/* Internal Imports */
import { remove0x } from '../utils'
const getStorageLayout = async (name: string): Promise<any> => {
const artifact: any = await readArtifact(bre.config.paths.artifacts, name)
return artifact.storageLayout
}
export const getModifiableStorageFactory = async (
name: string
): Promise<ContractFactory> => {
const contractFactory = await ethers.getContractFactory(name)
const proxyFactory = await ethers.getContractFactory(
'Helper_ModifiableStorage'
)
const originalDeployFn = contractFactory.deploy.bind(contractFactory)
contractFactory.deploy = async (...args: any[]): Promise<Contract> => {
const originalDefinePropertyFn = Object.defineProperty
Object.defineProperty = (obj: any, pname: string, prop: any): void => {
if (prop.writable === false) {
prop.writable = true
}
originalDefinePropertyFn(obj, pname, prop)
}
const contract: any = await originalDeployFn(...args)
const proxy = await proxyFactory.deploy(contract.address)
Object.defineProperty = originalDefinePropertyFn
contract.address = proxy.address
contract.resolvedAddress = proxy.address
contract.__setStorageSlot = proxy.__setStorageSlot.bind(proxy)
contract.__getStorageSlot = proxy.__getStorageSlot.bind(proxy)
contract.__setContractStorage = async (obj: any) => {
await setContractStorage(contract, await getStorageLayout(name), obj)
}
contract.__checkContractStorage = async (obj: any) => {
await checkContractStorage(contract, await getStorageLayout(name), obj)
}
return contract
}
return contractFactory
}
const flattenObject = (
obj: Object,
prefix: string = '',
res: Object = {}
): Object => {
if (_.isString(obj) || _.isNumber(obj) || _.isBoolean(obj)) {
res[prefix] = obj
return res
} else if (_.isArray(obj)) {
for (let i = 0; i < obj.length; i++) {
const pre = _.isEmpty(prefix) ? `${i}` : `${prefix}.${i}`
flattenObject(obj[i], pre, res)
}
return res
} else if (_.isPlainObject(obj)) {
for (const key of Object.keys(obj)) {
const pre = _.isEmpty(prefix) ? key : `${prefix}.${key}`
flattenObject(obj[key], pre, res)
}
return res
} else {
throw new Error('Cannot flatten unsupported object type.')
}
}
interface InputSlot {
label: string
slot: number
}
const getInputSlots = (
storageLayout: any,
inputTypeName: string
): InputSlot[] => {
const inputType = storageLayout.types[inputTypeName]
if (inputType.encoding === 'mapping') {
return getInputSlots(storageLayout, inputType.value)
} else if (inputType.encoding === 'inplace') {
if (inputType.members) {
return inputType.members.map((member: any) => {
return {
label: member.label,
slot: member.slot,
}
})
} else {
return [
{
label: 'default',
slot: 0,
},
]
}
} else {
throw new Error('Encoding type not supported.')
}
}
interface StorageSlot {
label: string
hash: string
value: string
}
const toHexString32 = (
value: string | number | BigNumber | boolean
): string => {
if (typeof value === 'string') {
return '0x' + remove0x(value).padStart(64, '0').toLowerCase()
} else if (typeof value === 'boolean') {
return toHexString32(value ? 1 : 0)
} else {
return toHexString32(BigNumber.from(value).toHexString())
}
}
const getStorageSlots = (storageLayout: any, obj: any): StorageSlot[] => {
const slots: StorageSlot[] = []
const flat = flattenObject(obj)
for (const key of Object.keys(flat)) {
const path = key.split('.')
const variableLabel = path[0]
const variableDef = storageLayout.storage.find((vDef: any) => {
return vDef.label === variableLabel
})
if (!variableDef) {
throw new Error(
`Could not find a matching variable definition for ${variableLabel}`
)
}
const baseSlot = parseInt(variableDef.slot, 10)
const baseDepth = (variableDef.type.match(/t_mapping/g) || []).length
const slotLabel =
path.length > 1 + baseDepth ? path[path.length - 1] : 'default'
const inputSlot = getInputSlots(storageLayout, variableDef.type).find(
(iSlot) => {
return iSlot.label === slotLabel
}
)
if (!inputSlot) {
throw new Error(
`Could not find a matching slot definition for ${slotLabel}`
)
}
let slotHash = toHexString32(baseSlot)
for (let i = 0; i < baseDepth; i++) {
slotHash = keccak256(toHexString32(path[i + 1]) + remove0x(slotHash))
}
slotHash = toHexString32(BigNumber.from(slotHash).add(inputSlot.slot))
slots.push({
label: key,
hash: slotHash,
value: toHexString32(flat[key]),
})
}
return slots
}
const setContractStorage = async (
contract: Contract,
layout: any,
obj: any
): Promise<void> => {
obj = obj || {}
if (!obj) {
return
}
const slots = getStorageSlots(layout, obj)
for (const slot of slots) {
await contract.__setStorageSlot(slot.hash, slot.value)
}
}
const checkContractStorage = async (
contract: Contract,
layout: any,
obj: any
): Promise<void> => {
obj = obj || {}
if (!obj) {
return
}
const slots = getStorageSlots(layout, obj)
for (const slot of slots) {
const value = await contract.__getStorageSlot(slot.hash)
if (value !== slot.value) {
throw new Error(
`Resulting state of ${slot.label} (${value}) did not match expected state (${slot.value}).`
)
}
}
}
packages/contracts/test/helpers/test-runner/test-runner.ts
View file @ c7b37b40
...@@ -4,6 +4,7 @@ import { expect } from '../../setup' ...@@ -4,6 +4,7 @@ import { expect } from '../../setup'
import { ethers } from '@nomiclabs/buidler' import { ethers } from '@nomiclabs/buidler'
import { Contract, BigNumber, ContractFactory } from 'ethers' import { Contract, BigNumber, ContractFactory } from 'ethers'
import { cloneDeep, merge } from 'lodash' import { cloneDeep, merge } from 'lodash'
import { smoddit, ModifiableContract } from '@eth-optimism/smock'
/* Internal Imports */ /* Internal Imports */
import { import {
...@@ -28,7 +29,6 @@ import { ...@@ -28,7 +29,6 @@ import {
isTestStep_REVERT, isTestStep_REVERT,
} from './test.types' } from './test.types'
import { encodeRevertData, REVERT_FLAGS } from '../codec' import { encodeRevertData, REVERT_FLAGS } from '../codec'
import { getModifiableStorageFactory } from '../storage'
import { import {
OVM_TX_GAS_LIMIT, OVM_TX_GAS_LIMIT,
RUN_OVM_TEST_GAS, RUN_OVM_TEST_GAS,
...@@ -39,8 +39,8 @@ export class ExecutionManagerTestRunner { ...@@ -39,8 +39,8 @@ export class ExecutionManagerTestRunner {
private snapshot: string private snapshot: string
private contracts: { private contracts: {
OVM_SafetyChecker: Contract OVM_SafetyChecker: Contract
OVM_StateManager: Contract OVM_StateManager: ModifiableContract
OVM_ExecutionManager: Contract OVM_ExecutionManager: ModifiableContract
Helper_TestRunner: Contract Helper_TestRunner: Contract
Factory__Helper_TestRunner_CREATE: ContractFactory Factory__Helper_TestRunner_CREATE: ContractFactory
} = { } = {
...@@ -82,8 +82,8 @@ export class ExecutionManagerTestRunner { ...@@ -82,8 +82,8 @@ export class ExecutionManagerTestRunner {
replacedParameter = this.setPlaceholderStrings(parameter) replacedParameter = this.setPlaceholderStrings(parameter)
}) })
beforeEach(async () => { beforeEach(() => {
await this.contracts.OVM_StateManager.__setContractStorage({ this.contracts.OVM_StateManager.smodify.set({
accounts: { accounts: {
[this.contracts.Helper_TestRunner.address]: { [this.contracts.Helper_TestRunner.address]: {
nonce: 0, nonce: 0,
...@@ -94,22 +94,27 @@ export class ExecutionManagerTestRunner { ...@@ -94,22 +94,27 @@ export class ExecutionManagerTestRunner {
}) })
}) })
beforeEach(async () => { beforeEach(() => {
await this.contracts.OVM_ExecutionManager.__setContractStorage( this.contracts.OVM_ExecutionManager.smodify.set(
replacedTest.preState.ExecutionManager replacedTest.preState.ExecutionManager
) )
await this.contracts.OVM_StateManager.__setContractStorage( this.contracts.OVM_StateManager.smodify.set(
replacedTest.preState.StateManager replacedTest.preState.StateManager
) )
}) })
afterEach(async () => { afterEach(async () => {
await this.contracts.OVM_ExecutionManager.__checkContractStorage( expect(
await this.contracts.OVM_ExecutionManager.smodify.check(
replacedTest.postState.ExecutionManager replacedTest.postState.ExecutionManager
) )
await this.contracts.OVM_StateManager.__checkContractStorage( ).to.equal(true)
expect(
await this.contracts.OVM_StateManager.smodify.check(
replacedTest.postState.StateManager replacedTest.postState.StateManager
) )
).to.equal(true)
}) })
const itfn = parameter.focus ? it.only : it const itfn = parameter.focus ? it.only : it
...@@ -143,10 +148,10 @@ export class ExecutionManagerTestRunner { ...@@ -143,10 +148,10 @@ export class ExecutionManagerTestRunner {
await ethers.getContractFactory('OVM_SafetyChecker') await ethers.getContractFactory('OVM_SafetyChecker')
).deploy() ).deploy()
this.contracts.OVM_ExecutionManager = await ( this.contracts.OVM_ExecutionManager = await (
await getModifiableStorageFactory('OVM_ExecutionManager') await smoddit('OVM_ExecutionManager')
).deploy(this.contracts.OVM_SafetyChecker.address) ).deploy(this.contracts.OVM_SafetyChecker.address)
this.contracts.OVM_StateManager = await ( this.contracts.OVM_StateManager = await (
await getModifiableStorageFactory('OVM_StateManager') await smoddit('OVM_StateManager')
).deploy(this.contracts.OVM_ExecutionManager.address) ).deploy(this.contracts.OVM_ExecutionManager.address)
this.contracts.Helper_TestRunner = await ( this.contracts.Helper_TestRunner = await (
await ethers.getContractFactory('Helper_TestRunner') await ethers.getContractFactory('Helper_TestRunner')
...@@ -264,7 +269,11 @@ export class ExecutionManagerTestRunner { ...@@ -264,7 +269,11 @@ export class ExecutionManagerTestRunner {
} else if (isTestStep_Context(step)) { } else if (isTestStep_Context(step)) {
return true return true
} else if (isTestStep_CALL(step)) { } else if (isTestStep_CALL(step)) {
if (isRevertFlagError(step.expectedReturnValue) && (step.expectedReturnValue.flag === REVERT_FLAGS.INVALID_STATE_ACCESS || step.expectedReturnValue.flag === REVERT_FLAGS.STATIC_VIOLATION)) { if (
isRevertFlagError(step.expectedReturnValue) &&
(step.expectedReturnValue.flag === REVERT_FLAGS.INVALID_STATE_ACCESS ||
step.expectedReturnValue.flag === REVERT_FLAGS.STATIC_VIOLATION)
) {
return step.expectedReturnStatus return step.expectedReturnStatus
} else { } else {
return true return true
......
packages/contracts/test/helpers/types/ovm-types.ts
View file @ c7b37b40
/* External Imports */
import { BigNumber } from 'ethers'
export interface OVMAccount { export interface OVMAccount {
nonce: number nonce: number | BigNumber
balance: number balance: number | BigNumber
storageRoot: string storageRoot: string
codeHash: string codeHash: string
ethAddress: string ethAddress: string
} }
/**
* Converts a raw ethers result to an OVM account.
* @param result Raw ethers transaction result.
* @returns Converted OVM account.
*/
export const toOVMAccount = (result: any[]): OVMAccount => {
return {
nonce: result[0].toNumber(),
balance: result[1].toNumber(),
storageRoot: result[2],
codeHash: result[3],
ethAddress: result[4],
}
}
packages/contracts/test/helpers/utils/eth-time.ts 0 → 100644
View file @ c7b37b40
export const getEthTime = async (provider: any): Promise<number> => {
return (await provider.getBlock('latest')).timestamp
}
export const setEthTime = async (
provider: any,
time: number
): Promise<void> => {
await provider.send('evm_setNextBlockTimestamp', [time])
}
export const increaseEthTime = async (
provider: any,
amount: number
): Promise<void> => {
await setEthTime(provider, (await getEthTime(provider)) + amount)
await provider.send('evm_mine', [])
}
export const getBlockTime = async (
provider: any,
block: number
): Promise<number> => {
await provider.send('evm_mine', [])
return (await provider.getBlock(block)).timestamp
}
packages/contracts/test/helpers/utils/index.ts
View file @ c7b37b40
export * from './buffer-utils' export * from './buffer-utils'
export * from './byte-utils' export * from './byte-utils'
export * from './eth-time'
packages/contracts/yarn.lock
View file @ c7b37b40
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment