Skip to content

N
nebula
Commit f63e3231 authored by Mark Tyneway's avatar Mark Tyneway Committed by GitHub
Browse files
Options

Merge pull request #5926 from ethereum-optimism/cleanup/remove-old-itests 

integration-tests: deprecate
parents cccce791 790c333e
Hide whitespace changes
Inline Side-by-side
Showing with 5 additions and 6021 deletions
.circleci/config.yml
View file @ f63e3231
......@@ -93,7 +93,6 @@ jobs:
- "packages/drippie-mon/node_modules"
- "packages/fault-detector/node_modules"
- "packages/hardhat-deploy-config/node_modules"
- "packages/integration-tests-bedrock/node_modules"
- "packages/message-relayer/node_modules"
- "packages/migration-data/node_modules"
- "packages/replica-healthcheck/node_modules"
......@@ -693,10 +692,6 @@ jobs:
name: Check sdk
command: npx depcheck
working_directory: packages/sdk
- run:
name: Check integration-tests
command: npx depcheck
working_directory: integration-tests
atst-tests:
docker:
......@@ -878,7 +873,7 @@ jobs:
steps:
- checkout
- check-changed:
patterns: op-(.+),packages,integration-tests
patterns: op-(.+),packages
- run:
name: Install latest golang
command: |
......@@ -1005,35 +1000,6 @@ jobs:
docker logs ops-bedrock-op-proposer-1 || echo "No logs."
when: on_fail
integration-tests:
machine:
image: ubuntu-2204:2022.07.1
environment:
DOCKER_BUILDKIT: 1
parallelism: 3
steps:
- checkout
- check-changed:
patterns: l2geth,common-ts,contracts,core-utils,message-relayer,data-transport-layer,replica-healthcheck,sdk,batch-submitter,gas-oracle,bss-core,integration-tests
- run:
name: Bring up the stack
command: |
docker-compose build --progress=plain
docker-compose up -d --scale replica_healthcheck=1
working_directory: ops
- run:
name: Wait for sequencer
command: bash scripts/wait-for-sequencer.sh
working_directory: ops
- run:
name: Run integration tests
command: |
circleci tests glob "../integration-tests/test/*.spec.ts" | circleci tests split | tee splits.txt
docker-compose run integration_tests $(cat splits.txt)
working_directory: ops
- run:
command: echo "Done."
semgrep-scan:
parameters:
diff_branch:
......@@ -1315,7 +1281,6 @@ workflows:
binary_name: op-heartbeat
working_directory: op-heartbeat
- geth-tests
- integration-tests
- semgrep-scan
- go-mod-tidy
- fuzz-op-node
......
.github/CODEOWNERS
View file @ f63e3231
......@@ -2,7 +2,6 @@
/batch-submitter @ethereum-optimism/legacy-reviewers
/bss-core @ethereum-optimism/legacy-reviewers
/gas-oracle @ethereum-optimism/legacy-reviewers
/integration-tests @ethereum-optimism/legacy-reviewers
/l2geth @ethereum-optimism/legacy-reviewers
/l2geth-exporter @ethereum-optimism/legacy-reviewers
/packages/actor-tests @ethereum-optimism/legacy-reviewers
......
.github/workflows/publish-canary.yml
View file @ f63e3231
......@@ -394,33 +394,6 @@ jobs:
push: true
tags: ethereumoptimism/deployer-bedrock:${{ needs.canary-publish.outputs.canary-docker-tag }}
integration_tests:
name: Publish Integration tests ${{ needs.canary-publish.outputs.integration-tests }}
needs: canary-publish
if: needs.canary-publish.outputs.integration-tests != ''
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v1
- name: Login to Docker Hub
uses: docker/login-action@v1
with:
username: ${{ secrets.DOCKERHUB_ACCESS_TOKEN_USERNAME }}
password: ${{ secrets.DOCKERHUB_ACCESS_TOKEN_SECRET }}
- name: Build and push
uses: docker/build-push-action@v2
with:
context: .
file: ./ops/docker/Dockerfile.packages
target: integration-tests
push: true
tags: ethereumoptimism/integration-tests:${{ needs.canary-publish.outputs.canary-docker-tag }}
replica-healthcheck:
name: Publish Replica Healthcheck Version ${{ needs.canary-publish.outputs.canary-docker-tag }}
needs: canary-publish
......
.github/workflows/release.yml
View file @ f63e3231
......@@ -507,33 +507,6 @@ jobs:
push: true
tags: ethereumoptimism/balance-monitor:${{ needs.release.outputs.balance-monitor }},ethereumoptimism/balance-monitor:latest
integration_tests:
name: Publish Integration tests ${{ needs.release.outputs.integration-tests }}
needs: release
if: needs.release.outputs.integration-tests != ''
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v1
- name: Login to Docker Hub
uses: docker/login-action@v1
with:
username: ${{ secrets.DOCKERHUB_ACCESS_TOKEN_USERNAME }}
password: ${{ secrets.DOCKERHUB_ACCESS_TOKEN_SECRET }}
- name: Build and push
uses: docker/build-push-action@v2
with:
context: .
file: ./ops/docker/Dockerfile.packages
target: integration-tests
push: true
tags: ethereumoptimism/integration-tests:${{ needs.release.outputs.integration-tests }},ethereumoptimism/integration-tests:latest
replica-healthcheck:
name: Publish Replica Healthcheck Version ${{ needs.release.outputs.replica-healthcheck }}
needs: release
......
.gitignore
View file @ f63e3231
......@@ -30,9 +30,6 @@ packages/contracts-periphery/forge-artifacts*
packages/data-transport-layer/db
packages/integration-tests-bedrock/cache
packages/integration-tests-bedrock/artifacts
packages/contracts-bedrock/deployments/devnetL1
packages/contracts-bedrock/deployments/anvil
......
CONTRIBUTING.md
View file @ f63e3231
......@@ -129,7 +129,6 @@ This will build the following containers:
* [`verifier`](https://hub.docker.com/r/ethereumoptimism/go-ethereum): L2 geth node running in Verifier mode
* [`relayer`](https://hub.docker.com/r/ethereumoptimism/message-relayer): helper process that relays messages between L1 and L2
* [`batch_submitter`](https://hub.docker.com/r/ethereumoptimism/batch-submitter-service): service that submits batches of Sequencer transactions to the L1 chain
* [`integration_tests`](https://hub.docker.com/r/ethereumoptimism/integration-tests): integration tests in a box
If you want to make a change to a container, you'll need to take it down and rebuild it.
For example, if you make a change in l2geth:
......@@ -193,16 +192,6 @@ cd packages/package-to-test
yarn test
```
#### Running integration tests
Follow above instructions for building the whole stack.
Build and run the integration tests:
```bash
cd integration-tests
yarn build
yarn test:integration
```
#### Running contract static analysis
We perform static analysis with [`slither`](https://github.com/crytic/slither).
......
README.md
View file @ f63e3231
......@@ -65,7 +65,6 @@ Refer to the Directory Structure section below to understand which packages are
├── <a href="./gas-oracle">gas-oracle</a>: Service for updating L1 gas prices on L2
├── <a href="./indexer">indexer</a>: indexes and syncs transactions
├── <a href="./infra/op-replica">infra/op-replica</a>: Deployment examples and resources for running an Optimism replica
├── <a href="./integration-tests">integration-tests</a>: Various integration tests for the Optimism network
├── <a href="./l2geth">l2geth</a>: Optimism client software, a fork of <a href="https://github.com/ethereum/go-ethereum/tree/v1.9.10">geth v1.9.10</a>
├── <a href="./l2geth-exporter">l2geth-exporter</a>: A prometheus exporter to collect/serve metrics from an L2 geth node
├── <a href="./op-exporter">op-exporter</a>: A prometheus exporter to collect/serve metrics from an Optimism node
......
integration-tests/.depcheckrc deleted 100644 → 0
View file @ cccce791
ignores: [
"@openzeppelin/contracts",
"@types/mocha",
"@types/rimraf",
"@uniswap/v3-core",
"mocha",
"typescript",
]
\ No newline at end of file
integration-tests/.env.example deleted 100644 → 0
View file @ cccce791
# only need to fill these out if you want to test against a prod network
PRIVATE_KEY=
L1_URL=
L2_URL=
ADDRESS_MANAGER=
L1_CROSS_DOMAIN_MESSENGER=
L1_STANDARD_BRIDGE=
STATE_COMMITMENT_CHAIN=
CANONICAL_TRANSACTION_CHAIN=
BOND_MANAGER=
L2_CHAINID=
DTL_ENQUEUE_CONFIRMATIONS=
OVMCONTEXT_SPEC_NUM_TXS=1
# Can be set to true below if the withdrawal window is short enough
RUN_WITHDRAWAL_TESTS=false
RUN_DEBUG_TRACE_TESTS=false
RUN_REPLICA_TESTS=false
RUN_HEALTHCHECK_TESTS=false
RUN_STRESS_TESTS=false
# Can be configured up or down as necessary
MOCHA_TIMEOUT=300000
# Set to true to make Mocha stop after the first failed test.
MOCHA_BAIL=false
integration-tests/.eslintrc.js deleted 100644 → 0
View file @ cccce791
module.exports = {
extends: '../.eslintrc.js',
}
integration-tests/.prettierrc.js deleted 100644 → 0
View file @ cccce791
module.exports = {
...require('../.prettierrc.js'),
}
integration-tests/CHANGELOG.md deleted 100644 → 0
View file @ cccce791
# @eth-optimism/integration-tests
## 0.5.22
### Patch Changes
- 1d3c749a2: Bumps the version of ts-node used
- 1d3c749a2: Updates the version of TypeScript
## 0.5.21
### Patch Changes
- a3242d4f: Fix erc721 factory to match erc21 factory
## 0.5.20
### Patch Changes
- 02c457a5: Removes NFT refund logic if withdrawals fail.
## 0.5.19
### Patch Changes
- 5c3f2b1f: Fixes NFT bridge related contracts in response to the OpenZeppelin audit. Updates tests to support these changes, including integration tests.
## 0.5.18
### Patch Changes
- 7215f4ce: Bump ethers to 5.7.0 globally
## 0.5.17
### Patch Changes
- d97df13a: Modularize the itests away from depending on api of messenger
## 0.5.16
### Patch Changes
- 977493bc: Update SDK version and usage to account for new constructor
## 0.5.15
### Patch Changes
- 29ff7462: Revert es target back to 2017
## 0.5.14
### Patch Changes
- f688a631: integration-tests: Override default bridge adapters
- d18ae135: Updates all ethers versions in response to BN.js bug
## 0.5.13
### Patch Changes
- 412688d5: Replace calls to getNetwork() with getChainId util
## 0.5.12
### Patch Changes
- 53fac1df: Facilitate actor testing on nightly
## 0.5.11
### Patch Changes
- 36a91c30: Fix various actor tests
## 0.5.10
### Patch Changes
- db02f97f: Add tests for system addrs on verifiers/replicas
## 0.5.9
### Patch Changes
- 5bf390b4: Update chainid
- c1957126: Update Dockerfile to use Alpine
- d9a51154: Bump to hardhat@2.9.1
## 0.5.8
### Patch Changes
- 88807f03: Add integration test for healthcheck server
## 0.5.7
### Patch Changes
- 88601cb7: Refactored Dockerfiles
## 0.5.6
### Patch Changes
- 962f36e4: Add support for system addresses
- d6e309be: Add test coverage for zlib compressed batches
- 386df4dc: Replaces contract references in integration tests with SDK CrossChainMessenger objects.
## 0.5.5
### Patch Changes
- 45642dc8: Replaces l1Provider and l2Provider with env.l1Provider and env.l2Provider respectively.
## 0.5.4
### Patch Changes
- dc5f6517: Deletes watcher-utils.ts. Moves it's utilities into env.ts.
- dcdcc757: Removes message relaying utilities from the Message Relayer, to be replaced by the SDK
## 0.5.3
### Patch Changes
- a8a74a98: Remove Watcher usage from itests
- e2ad8653: Support non-well-known networks
- 152df378: Use new asL2Provider function for integration tests
- 748c04ab: Updates integration tests to use the SDK for bridged token tests
- 8cb2535b: Skip an unreliable test
## 0.5.2
### Patch Changes
- d6c2830a: Increase withdrawal test timeout
- 0293749e: Add an integration test showing the infeasability of withdrawing a fake token in exchange for a legitimate token.
- a135aa3d: Updates integration tests to include a test for syncing a Verifier from L1
- 0bb11484: Remove nightly itests - not needed anymore
- ba14c59d: Updates various ethers dependencies to their latest versions
- a135aa3d: Add verifier integration tests
- edb21845: Updates integration tests to start using SDK
## 0.5.1
### Patch Changes
- e631c39c: Add in berlin hardfork tests
## 0.5.0
### Minor Changes
- c1e923f9: Updates to work with a live network
### Patch Changes
- 968fb38d: Use hardhat-ethers for importing factories in integration tests
- a7fbafa8: Split OVMMulticall.sol into Multicall.sol & OVMContext.sol
## 0.4.2
### Patch Changes
- 5787a55b: Updates to support nightly actor tests
- dad6fd9b: Update timestamp assertion for new logic
## 0.4.1
### Patch Changes
- a8013127: Remove sync-tests as coverage lives in itests now
- b1fa3f33: Enforce fees in docker-compose setup and test cases for fee too low and fee too high
- 4559a824: Pass through starting block height to dtl
## 0.4.0
### Minor Changes
- 3ce64804: Add actor tests
## 0.3.3
### Patch Changes
- 0ab37fc9: Update to node.js version 16
## 0.3.2
### Patch Changes
- d141095c: Allow for unprotected transactions
## 0.3.1
### Patch Changes
- 243f33e5: Standardize package json file format
## 0.3.0
### Minor Changes
- e03dcead: Start refactor to new version of the OVM
- e4a1129c: Adds aliasing to msg.sender and tx.origin to avoid xdomain attacks
- 3f590e33: Remove the "OVM" Prefix from contract names
- 872f5976: Removes various unused OVM contracts
- 92c9692d: Opcode tweaks. Coinbase returns SequencerFeeVault address. Difficulty returns zero.
- 1e63ffa0: Refactors and simplifies OVM_ETH usage
- b56dd079: Updates the deployment process to correctly set all constants and adds more integration tests
- 81ccd6e4: `regenesis/0.5.0` release
- f38b8000: Removes ERC20 and WETH9 features from OVM_ETH
- 3605b963: Adds refactored support for the L1MESSAGESENDER opcode
### Patch Changes
- 299a459e: Introduces a new opcode L1BLOCKNUMBER to replace old functionality where blocknumber would return the L1 block number and the L2 block number was inaccessible.
- 343da72a: Add tests for optimistic ethereum related fields to the receipt
- 7b761af5: Add updated fee scheme integration tests
- b70ee70c: upgraded to solidity 0.8.9
- a98a1884: Fixes dependencies instead of using caret constraints
## 0.2.4
### Patch Changes
- 6d3e1d7f: Update dependencies
## 0.2.3
### Patch Changes
- 918c08ca: Bump ethers dependency to 5.4.x to support eip1559
## 0.2.2
### Patch Changes
- c73c3939: Update the typescript version to `4.3.5`
## 0.2.1
### Patch Changes
- f1dc8b77: Add various stress tests
## 0.2.0
### Minor Changes
- aa6fad84: Various updates to integration tests so that they can be executed against production networks
## 0.1.2
### Patch Changes
- b107a032: Make expectApprox more readable by passing optional args as an object with well named keys
## 0.1.1
### Patch Changes
- 40b99a6e: Add new RPC endpoint `rollup_gasPrices`
## 0.1.0
### Minor Changes
- e04de624: Add support for ovmCALL with nonzero ETH value
### Patch Changes
- 25f09abd: Adds ERC1271 support to default contract account
- 5fc728da: Add a new Standard Token Bridge, to handle deposits and withdrawals of any ERC20 token.
For projects developing a custom bridge, if you were previously importing `iAbs_BaseCrossDomainMessenger`, you should now
import `iOVM_CrossDomainMessenger`.
- c43b33ec: Add WETH9 compatible deposit and withdraw functions to OVM_ETH
- e045f582: Adds new SequencerFeeVault contract to store generated fees
- b8e2d685: Add replica sync test to integration tests; handle 0 L2 blocks in DTL
## 0.0.7
### Patch Changes
- d1680052: Reduce test timeout from 100 to 20 seconds
- c2b6e14b: Implement the latest fee spec such that the L2 gas limit is scaled and the tx.gasPrice/tx.gasLimit show correctly in metamask
- 77108d37: Add verifier sync test and extra docker-compose functions
## 0.0.6
### Patch Changes
- f091e86: Fix to ensure that L1 => L2 success status is reflected correctly in receipts
- f880479: End to end fee integration with recoverable L2 gas limit
## 0.0.5
### Patch Changes
- 467d6cb: Adds a test for contract deployments that run out of gas
## 0.0.4
### Patch Changes
- b799caa: Add support for parsed revert reasons in DoEstimateGas
- b799caa: Update minimum response from estimate gas
- b799caa: Add value transfer support to ECDSAContractAccount
- b799caa: Update expected gas prices based on minimum of 21k value
## 0.0.3
### Patch Changes
- 6daa408: update hardhat versions so that solc is resolved correctly
- 5b9be2e: Correctly set the OVM context based on the L1 values during `eth_call`. This will also set it during `eth_estimateGas`. Add tests for this in the integration tests
## 0.0.2
### Patch Changes
- 6bcf22b: Add contracts for OVM context test coverage and add tests
integration-tests/LICENSE deleted 100644 → 0
View file @ cccce791
(The MIT License)
Copyright 2020-2021 Optimism
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
integration-tests/README.md deleted 100644 → 0
View file @ cccce791
# @eth-optimism/integration-tests
Note that these tests are ran against the legacy system, see `op-e2e` for
the bedrock test suite.
## Setup
Follow installation + build instructions in the [primary README](../README.md).
Then, run:
```bash
yarn build
```
## Running integration tests
### Testing a live network
Testing on a live network is a bit more complicated than testing locally. You'll need the following in order to do so:
1. A pre-funded wallet with at least 40 ETH.
2. URLs to an L1 and L2 node.
3. The address of the address manager contract.
4. The chain ID of the L2.
Once you have all the necessary info, create a `.env` file like the one in `.env.example` and fill it in with the values above. Then, run:
```bash
yarn test:integration:live
```
This will take quite a long time. Kovan, for example, takes about 30 minutes to complete.
You can also set environment variables on the command line instead of inside `.env` if you want:
```bash
L1_URL=whatever L2_URL=whatever yarn test:integration:live
```
To run the Uniswap integration tests against a deployed set of Uniswap contracts, add the following env vars:
```
UNISWAP_POSITION_MANAGER_ADDRESS=<non fungible position manager address>
UNISWAP_ROUTER_ADDRESS=<router address>
```
## Running actor tests
Actor tests use the same environment variables as the integration tests, so set up your `.env` file if you haven't
already. Then, run `yarn test:actor <args>` to run the tests. Note that it will be **very expensive** to run the actor
tests against mainnet, and that the tests can take a while to complete.
See [actor-tests/README.md](actor-tests/README.md) for information on actor tests.
integration-tests/contracts/ConstructorReverter.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import { Reverter } from './Reverter.sol';
contract ConstructorReverter is Reverter {
constructor() {
doRevert();
}
}
integration-tests/contracts/ERC20.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
contract ERC20 {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
string public name; //fancy name: eg OVM Coin
uint8 public decimals; //How many decimals to show.
string public symbol; //An identifier: eg OVM
uint256 public totalSupply;
constructor(
uint256 _initialAmount,
string memory _tokenName,
uint8 _decimalUnits,
string memory _tokenSymbol
) public {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
totalSupply = _initialAmount; // Update total supply
name = _tokenName; // Set the name for display purposes
decimals = _decimalUnits; // Amount of decimals for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value, "insufficient balance");
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value, "bad allowance");
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function destroy() public {
selfdestruct(payable(msg.sender));
}
}
integration-tests/contracts/FakeL2StandardERC20.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
contract FakeL2StandardERC20 {
address public immutable l1Token;
address public immutable l2Bridge;
constructor(address _l1Token, address _l2Bridge) {
l1Token = _l1Token;
l2Bridge = _l2Bridge;
}
// Burn will be called by the L2 Bridge to burn the tokens we are bridging to L1
function burn(address, uint256) external {}
}
integration-tests/contracts/FakeOptimismMintableERC721.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import { OptimismMintableERC721 } from "@eth-optimism/contracts-bedrock/contracts/universal/OptimismMintableERC721.sol";
import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract FakeOptimismMintableERC721 is OptimismMintableERC721 {
constructor(
address _bridge,
address _remoteToken,
uint256 _remoteChainId
) OptimismMintableERC721(
_bridge,
_remoteChainId,
_remoteToken,
"FakeERC721",
"FAKE"
) {}
function safeMint(address to, uint256 tokenId) external override {
_safeMint(to, tokenId);
}
// Burn will be called by the L2 Bridge to burn the NFT we are bridging to L1
function burn(address, uint256 tokenId) external override {
_burn(tokenId);
}
}
integration-tests/contracts/Multicall.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
pragma experimental ABIEncoderV2;
// https://github.com/makerdao/multicall/blob/master/src/Multicall.sol
/// @title Multicall - Aggregate results from multiple read-only function calls
/// @author Michael Elliot <mike@makerdao.com>
/// @author Joshua Levine <joshua@makerdao.com>
/// @author Nick Johnson <arachnid@notdot.net>
contract Multicall {
struct Call {
address target;
bytes callData;
}
function aggregate(Call[] memory calls) public returns (uint256 blockNumber, bytes[] memory returnData) {
blockNumber = block.number;
returnData = new bytes[](calls.length);
for (uint256 i = 0; i < calls.length; i++) {
(bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
require(success);
returnData[i] = ret;
}
}
// Helper functions
function getEthBalance(address addr) public view returns (uint256 balance) {
balance = addr.balance;
}
function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
blockHash = blockhash(blockNumber);
}
function getLastBlockHash() public view returns (bytes32 blockHash) {
blockHash = blockhash(block.number - 1);
}
function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
timestamp = block.timestamp;
}
function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
difficulty = block.difficulty;
}
function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
gaslimit = block.gaslimit;
}
function getCurrentBlockCoinbase() public view returns (address coinbase) {
coinbase = block.coinbase;
}
}
integration-tests/contracts/NFT.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract NFT is ERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
constructor() ERC721("OVM NFT", "ONFT") {
}
function give() public {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(msg.sender, newItemId);
}
}
\ No newline at end of file
integration-tests/contracts/OVMContext.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
/*
MIT License
Copyright (c) 2018 Maker Foundation
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*/
pragma solidity ^0.8.9;
// Can't do this until the package is published.
//import { iOVM_L1BlockNumber } from "@eth-optimism/contracts/iOVM_L1BlockNumber";
interface iOVM_L1BlockNumber {
function getL1BlockNumber() external view returns (uint256);
}
/// @title OVMContext - Helper Functions
contract OVMContext {
function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
timestamp = block.timestamp;
}
function getCurrentL1BlockNumber() public view returns (uint256) {
return iOVM_L1BlockNumber(
0x4200000000000000000000000000000000000013
).getL1BlockNumber();
}
function getCurrentBlockNumber() public view returns (uint256) {
return block.number;
}
function getChainID() external view returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
}
integration-tests/contracts/OVMContextStorage.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import {OVMContext} from "./OVMContext.sol";
contract OVMContextStorage is OVMContext {
mapping(uint256 => uint256) public l1BlockNumbers;
mapping(uint256 => uint256) public blockNumbers;
mapping(uint256 => uint256) public timestamps;
mapping(uint256 => uint256) public difficulty;
mapping(uint256 => address) public coinbases;
uint256 public index = 0;
fallback() external {
l1BlockNumbers[index] = getCurrentL1BlockNumber();
blockNumbers[index] = getCurrentBlockNumber();
timestamps[index] = getCurrentBlockTimestamp();
difficulty[index] = block.difficulty;
coinbases[index] = block.coinbase;
index++;
}
}
integration-tests/contracts/Precompiles.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
contract Precompiles {
function expmod(uint256 base, uint256 e, uint256 m) public returns (uint256 o) {
assembly {
// define pointer
let p := mload(0x40)
// store data assembly-favouring ways
mstore(p, 0x20) // Length of Base
mstore(add(p, 0x20), 0x20) // Length of Exponent
mstore(add(p, 0x40), 0x20) // Length of Modulus
mstore(add(p, 0x60), base) // Base
mstore(add(p, 0x80), e) // Exponent
mstore(add(p, 0xa0), m) // Modulus
if iszero(staticcall(sub(gas(), 2000), 0x05, p, 0xc0, p, 0x20)) {
revert(0, 0)
}
// data
o := mload(p)
}
}
}
integration-tests/contracts/Proxy.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
* @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
* instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
* be specified by overriding the virtual {_implementation} function.
*
* Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
* different contract through the {_delegate} function.
*
* The success and return data of the delegated call will be returned back to the caller of the proxy.
*/
abstract contract Proxy {
/**
* @dev Delegates the current call to `implementation`.
*
* This function does not return to its internall call site, it will return directly to the external caller.
*/
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
/**
* @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
* and {_fallback} should delegate.
*/
function _implementation() internal view virtual returns (address);
/**
* @dev Delegates the current call to the address returned by `_implementation()`.
*
* This function does not return to its internall call site, it will return directly to the external caller.
*/
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
/**
* @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
* function in the contract matches the call data.
*/
fallback () external payable virtual {
_fallback();
}
/**
* @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
* is empty.
*/
receive () external payable virtual {
_fallback();
}
/**
* @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
* call, or as part of the Solidity `fallback` or `receive` functions.
*
* If overriden should call `super._beforeFallback()`.
*/
function _beforeFallback() internal virtual {
}
}
integration-tests/contracts/Reverter.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
contract Reverter {
string constant public revertMessage = "This is a simple reversion.";
function doRevert() public pure {
revert(revertMessage);
}
}
integration-tests/contracts/SelfDestruction.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
contract SelfDestruction {
bytes32 public data = 0x0000000000000000000000000000000000000000000000000000000061626364;
function setData(bytes32 _data) public {
data = _data;
}
function destruct() public {
address payable self = payable(address(this));
selfdestruct(self);
}
}
integration-tests/contracts/SimpleStorage.sol deleted 100644 → 0
View file @ cccce791
pragma solidity ^0.8.9;
contract ICrossDomainMessenger {
address public xDomainMessageSender;
}
contract SimpleStorage {
address public msgSender;
address public txOrigin;
address public xDomainSender;
bytes32 public value;
uint256 public totalCount;
function setValue(bytes32 newValue) public {
msgSender = msg.sender;
txOrigin = tx.origin;
xDomainSender = ICrossDomainMessenger(msg.sender)
.xDomainMessageSender();
value = newValue;
totalCount++;
}
function setValueNotXDomain(bytes32 newValue) public {
msgSender = msg.sender;
txOrigin = tx.origin;
value = newValue;
totalCount++;
}
function dumbSetValue(bytes32 newValue) public {
value = newValue;
}
}
integration-tests/contracts/StateDOS.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
contract StateDOS {
bool public hasRun = false;
function attack() public {
// jumpdest ; jump label, start of loop
// gas ; get a 'random' value on the stack
// extcodesize ; trigger trie lookup
// pop ; ignore the extcodesize result
// push1 0x00 ; jump label dest
// jump ; jump back to start
assembly {
let thegas := gas()
// While greater than 23000 gas. This will let us SSTORE at the end.
for { } gt(thegas, 0x59D8) { } {
thegas := gas()
let ignoredext := extcodesize(thegas)
}
}
hasRun = true; // Sanity check
}
}
\ No newline at end of file
integration-tests/contracts/TestOOG.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
contract TestOOG {
function runOutOfGas() public {
bytes32 h;
for (uint256 i = 0; i < 100000; i++) {
h = keccak256(abi.encodePacked(h));
}
}
}
contract TestOOGInConstructor is TestOOG {
constructor() {
runOutOfGas();
}
}
integration-tests/contracts/ValueCalls.sol deleted 100644 → 0
View file @ cccce791
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
contract ValueContext {
function getSelfBalance() external payable returns(uint256) {
uint selfBalance;
assembly {
selfBalance := selfbalance()
}
return selfBalance;
}
function getAddressThisBalance() external view returns(uint256) {
return address(this).balance;
}
function getBalance(
address _address
) external payable returns(uint256) {
return _address.balance;
}
function getCallValue() public payable returns(uint256) {
return msg.value;
}
function getCaller() external view returns (address){
return msg.sender;
}
}
contract ValueCalls is ValueContext {
receive() external payable {}
function nonPayable() external {}
function simpleSend(
address _address,
uint _value
) external payable returns (bool, bytes memory) {
return sendWithData(_address, _value, hex"");
}
function sendWithDataAndGas(
address _address,
uint _value,
uint _gasLimit,
bytes memory _calldata
) public returns (bool, bytes memory) {
return _address.call{value: _value, gas: _gasLimit}(_calldata);
}
function sendWithData(
address _address,
uint _value,
bytes memory _calldata
) public returns (bool, bytes memory) {
return _address.call{value: _value}(_calldata);
}
function verifyCallValueAndRevert(
uint256 _expectedValue
) external payable {
bool correct = _checkCallValue(_expectedValue);
// do the opposite of expected if the value is wrong.
if (correct) {
revert("expected revert");
} else {
return;
}
}
function verifyCallValueAndReturn(
uint256 _expectedValue
) external payable {
bool correct = _checkCallValue(_expectedValue);
// do the opposite of expected if the value is wrong.
if (correct) {
return;
} else {
revert("unexpected revert");
}
}
function delegateCallToCallValue(
address _valueContext
) public payable returns(bool, bytes memory) {
bytes memory data = abi.encodeWithSelector(ValueContext.getCallValue.selector);
return _valueContext.delegatecall(data);
}
function delegateCallToAddressThisBalance(
address _valueContext
) public payable returns(bool, bytes memory) {
bytes memory data = abi.encodeWithSelector(ValueContext.getAddressThisBalance.selector);
return _valueContext.delegatecall(data);
}
function _checkCallValue(
uint256 _expectedValue
) internal returns(bool) {
return getCallValue() == _expectedValue;
}
}
contract ValueGasMeasurer {
function measureGasOfTransferingEthViaCall(
address target,
uint256 value,
uint256 gasLimit
) public returns(uint256) {
uint256 gasBefore = gasleft();
assembly {
pop(call(gasLimit, target, value, 0, 0, 0, 0))
}
return gasBefore - gasleft();
}
}
contract PayableConstant {
function returnValue() external payable returns(uint256) {
return 42;
}
}
contract SendETHAwayAndDelegateCall {
function emptySelfAndDelegateCall(
address _delegateTo,
bytes memory _data
) public payable returns (bool, bytes memory) {
address(0).call{value: address(this).balance}(_data);
return _delegateTo.delegatecall(_data);
}
}
integration-tests/ext-test/snx.sh deleted 100755 → 0
View file @ cccce791
#!/bin/bash
git clone --depth=1 --branch develop https://github.com/Synthetixio/synthetix.git
cd synthetix
npm install
npx hardhat --config ./hardhat.config.js test:integration:dual --compile --deploy
integration-tests/hardhat.config.ts deleted 100644 → 0
View file @ cccce791
import { HardhatUserConfig } from 'hardhat/types'
// Hardhat plugins
import '@nomiclabs/hardhat-ethers'
import '@nomiclabs/hardhat-waffle'
import 'hardhat-gas-reporter'
import './tasks/check-block-hashes'
import { envConfig } from './test/shared/utils'
const enableGasReport = !!process.env.ENABLE_GAS_REPORT
const config: HardhatUserConfig = {
networks: {
optimism: {
url: process.env.L2_URL || 'http://localhost:8545',
},
},
mocha: {
timeout: envConfig.MOCHA_TIMEOUT,
bail: envConfig.MOCHA_BAIL,
},
solidity: {
compilers: [
{
version: '0.7.6',
settings: {},
},
{
version: '0.8.9',
settings: {
optimizer: { enabled: true, runs: 200 },
metadata: {
bytecodeHash: 'none',
},
outputSelection: {
'*': {
'*': ['storageLayout'],
},
},
},
},
{
version: '0.8.15',
settings: {
optimizer: { enabled: true, runs: 200 },
metadata: {
bytecodeHash: 'none',
},
outputSelection: {
'*': {
'*': ['storageLayout'],
},
},
},
},
],
},
gasReporter: {
enabled: enableGasReport,
currency: 'USD',
gasPrice: 100,
outputFile: process.env.CI ? 'gas-report.txt' : undefined,
},
}
export default config
integration-tests/package.json deleted 100644 → 0
View file @ cccce791
{
"private": true,
"name": "@eth-optimism/integration-tests",
"version": "0.5.22",
"description": "[Optimism] Integration tests",
"scripts": {
"lint": "yarn lint:fix && yarn lint:check",
"lint:fix": "yarn lint:check --fix",
"lint:check": "eslint . --max-warnings=0",
"build": "hardhat compile",
"test:integration": "hardhat --network optimism test",
"test:actor": "IS_LIVE_NETWORK=true ts-node actor-tests/lib/runner.ts",
"test:integration:live": "NO_NETWORK=true IS_LIVE_NETWORK=true hardhat --network optimism test",
"clean": "rimraf cache artifacts",
"pre-commit": "lint-staged"
},
"keywords": [
"optimism",
"ethereum",
"integration",
"tests"
],
"homepage": "https://github.com/ethereum-optimism/optimism/tree/develop/packages/integration-tests#readme",
"license": "MIT",
"author": "Optimism PBC",
"repository": {
"type": "git",
"url": "https://github.com/ethereum-optimism/optimism.git"
},
"devDependencies": {
"@babel/eslint-parser": "^7.5.4",
"@eth-optimism/contracts": "^0.6.0",
"@eth-optimism/contracts-bedrock": "0.14.0",
"@eth-optimism/contracts-periphery": "^1.0.8",
"@eth-optimism/core-utils": "0.12.0",
"@eth-optimism/sdk": "2.1.0",
"@ethersproject/abstract-provider": "^5.7.0",
"@ethersproject/providers": "^5.7.0",
"@ethersproject/transactions": "^5.7.0",
"@nomiclabs/hardhat-ethers": "^2.0.2",
"@nomiclabs/hardhat-waffle": "^2.0.1",
"@openzeppelin/contracts": "^4.4.0",
"@types/chai": "^4.2.18",
"@types/chai-as-promised": "^7.1.4",
"@types/mocha": "^8.2.2",
"@types/rimraf": "^3.0.0",
"@typescript-eslint/eslint-plugin": "^5.45.1",
"@typescript-eslint/parser": "^5.45.1",
"@uniswap/v3-core": "1.0.0",
"@uniswap/v3-periphery": "^1.0.1",
"@uniswap/v3-sdk": "^3.6.2",
"chai": "^4.3.4",
"chai-as-promised": "^7.1.1",
"dotenv": "^10.0.0",
"envalid": "^7.1.0",
"eslint": "^7.27.0",
"eslint-config-prettier": "^8.3.0",
"eslint-plugin-import": "^2.26.0",
"eslint-plugin-jsdoc": "^35.1.2",
"eslint-plugin-prefer-arrow": "^1.2.3",
"eslint-plugin-prettier": "^3.4.0",
"eslint-plugin-react": "^7.24.0",
"eslint-plugin-unicorn": "^42.0.0",
"ethereum-waffle": "^3.3.0",
"ethers": "^5.7.0",
"hardhat": "^2.9.6",
"hardhat-gas-reporter": "^1.0.4",
"lint-staged": "11.0.0",
"mocha": "^8.4.0",
"node-fetch": "^2.6.7",
"rimraf": "^3.0.2",
"typescript": "^4.9.3",
"uniswap-v3-deploy-plugin": "^0.1.0"
}
}
integration-tests/tasks/check-block-hashes.ts deleted 100644 → 0
View file @ cccce791
import { task } from 'hardhat/config'
import { providers } from 'ethers'
import { getChainId } from '@eth-optimism/core-utils'
import { die, logStderr } from '../test/shared/utils'
task(
'check-block-hashes',
'Compares the block hashes of two different replicas.'
)
.addPositionalParam('replicaA', 'The first replica')
.addPositionalParam('replicaB', 'The second replica')
.setAction(async ({ replicaA, replicaB }) => {
const providerA = new providers.JsonRpcProvider(replicaA)
const providerB = new providers.JsonRpcProvider(replicaB)
let chainIdA
let chainIdB
try {
chainIdA = await getChainId(providerA)
} catch (e) {
console.error(`Error getting network chainId from ${replicaA}:`)
die(e)
}
try {
chainIdB = await getChainId(providerB)
} catch (e) {
console.error(`Error getting network chainId from ${replicaB}:`)
die(e)
}
if (chainIdA !== chainIdB) {
die('Chain IDs do not match')
return
}
logStderr('Getting block height.')
const heightA = await providerA.getBlockNumber()
const heightB = await providerB.getBlockNumber()
const endHeight = Math.min(heightA, heightB)
logStderr(`Chose block height: ${endHeight}`)
for (let n = endHeight; n >= 1; n--) {
const blocks = await Promise.all([
providerA.getBlock(n),
providerB.getBlock(n),
])
const hashA = blocks[0].hash
const hashB = blocks[1].hash
if (hashA !== hashB) {
console.log(`HASH MISMATCH! block=${n} a=${hashA} b=${hashB}`)
continue
}
console.log(`HASHES OK! block=${n} hash=${hashA}`)
return
}
})
integration-tests/test/basic-l1-l2-communication.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { Contract, ContractFactory } from 'ethers'
import { ethers } from 'hardhat'
import { MessageDirection, MessageStatus } from '@eth-optimism/sdk'
import {
applyL1ToL2Alias,
awaitCondition,
sleep,
} from '@eth-optimism/core-utils'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import {
DEFAULT_TEST_GAS_L1,
DEFAULT_TEST_GAS_L2,
envConfig,
withdrawalTest,
} from './shared/utils'
describe('Basic L1<>L2 Communication', async () => {
let Factory__L1SimpleStorage: ContractFactory
let Factory__L2SimpleStorage: ContractFactory
let Factory__L2Reverter: ContractFactory
let L1SimpleStorage: Contract
let L2SimpleStorage: Contract
let L2Reverter: Contract
let env: OptimismEnv
before(async () => {
env = await OptimismEnv.new()
Factory__L1SimpleStorage = await ethers.getContractFactory(
'SimpleStorage',
env.l1Wallet
)
Factory__L2SimpleStorage = await ethers.getContractFactory(
'SimpleStorage',
env.l2Wallet
)
Factory__L2Reverter = await ethers.getContractFactory(
'Reverter',
env.l2Wallet
)
})
beforeEach(async () => {
L1SimpleStorage = await Factory__L1SimpleStorage.deploy()
await L1SimpleStorage.deployed()
L2SimpleStorage = await Factory__L2SimpleStorage.deploy()
await L2SimpleStorage.deployed()
L2Reverter = await Factory__L2Reverter.deploy()
await L2Reverter.deployed()
})
describe('L2 => L1', () => {
withdrawalTest(
'should be able to perform a withdrawal from L2 -> L1',
async () => {
const value = `0x${'77'.repeat(32)}`
// Send L2 -> L1 message.
const transaction = await env.messenger.sendMessage(
{
direction: MessageDirection.L2_TO_L1,
target: L1SimpleStorage.address,
message: L1SimpleStorage.interface.encodeFunctionData('setValue', [
value,
]),
},
{
overrides: {
gasLimit: DEFAULT_TEST_GAS_L2,
},
}
)
await env.messenger.waitForMessageStatus(
transaction,
MessageStatus.READY_FOR_RELAY
)
await env.messenger.finalizeMessage(transaction)
await env.messenger.waitForMessageReceipt(transaction)
expect(await L1SimpleStorage.msgSender()).to.equal(
env.messenger.contracts.l1.L1CrossDomainMessenger.address
)
expect(await L1SimpleStorage.xDomainSender()).to.equal(
await env.messenger.l2Signer.getAddress()
)
expect(await L1SimpleStorage.value()).to.equal(value)
expect((await L1SimpleStorage.totalCount()).toNumber()).to.equal(1)
}
)
})
describe('L1 => L2', () => {
it('should deposit from L1 -> L2', async () => {
const value = `0x${'42'.repeat(32)}`
// Send L1 -> L2 message.
const transaction = await env.messenger.sendMessage(
{
direction: MessageDirection.L1_TO_L2,
target: L2SimpleStorage.address,
message: L2SimpleStorage.interface.encodeFunctionData('setValue', [
value,
]),
},
{
l2GasLimit: 5000000,
overrides: {
gasLimit: DEFAULT_TEST_GAS_L1,
},
}
)
const receipt = await env.messenger.waitForMessageReceipt(transaction)
expect(receipt.transactionReceipt.status).to.equal(1)
expect(await L2SimpleStorage.msgSender()).to.equal(
env.messenger.contracts.l2.L2CrossDomainMessenger.address
)
expect(await L2SimpleStorage.txOrigin()).to.equal(
applyL1ToL2Alias(
env.messenger.contracts.l1.L1CrossDomainMessenger.address
)
)
expect(await L2SimpleStorage.xDomainSender()).to.equal(
await env.messenger.l1Signer.getAddress()
)
expect(await L2SimpleStorage.value()).to.equal(value)
expect((await L2SimpleStorage.totalCount()).toNumber()).to.equal(1)
})
it('should deposit from L1 -> L2 directly via enqueue', async function () {
this.timeout(
envConfig.MOCHA_TIMEOUT * 2 +
envConfig.DTL_ENQUEUE_CONFIRMATIONS * 15000
)
const value = `0x${'42'.repeat(32)}`
// Send L1 -> L2 message.
const tx =
await env.messenger.contracts.l1.CanonicalTransactionChain.connect(
env.messenger.l1Signer
).enqueue(
L2SimpleStorage.address,
5000000,
L2SimpleStorage.interface.encodeFunctionData('setValueNotXDomain', [
value,
]),
{
gasLimit: DEFAULT_TEST_GAS_L1,
}
)
const receipt = await tx.wait()
const waitUntilBlock =
receipt.blockNumber + envConfig.DTL_ENQUEUE_CONFIRMATIONS
let currBlock = await env.messenger.l1Provider.getBlockNumber()
while (currBlock <= waitUntilBlock) {
const progress =
envConfig.DTL_ENQUEUE_CONFIRMATIONS - (waitUntilBlock - currBlock)
console.log(
`Waiting for ${progress}/${envConfig.DTL_ENQUEUE_CONFIRMATIONS} confirmations.`
)
await sleep(5000)
currBlock = await env.messenger.l1Provider.getBlockNumber()
}
console.log('Enqueue should be confirmed.')
await awaitCondition(
async () => {
const sender = await L2SimpleStorage.msgSender()
return sender === (await env.messenger.l1Signer.getAddress())
},
2000,
60
)
// No aliasing when an EOA goes directly to L2.
expect(await L2SimpleStorage.msgSender()).to.equal(
await env.messenger.l1Signer.getAddress()
)
expect(await L2SimpleStorage.txOrigin()).to.equal(
await env.messenger.l1Signer.getAddress()
)
expect(await L2SimpleStorage.value()).to.equal(value)
expect((await L2SimpleStorage.totalCount()).toNumber()).to.equal(1)
})
})
})
integration-tests/test/bridged-tokens.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { BigNumber, Contract, ContractFactory, utils, Wallet } from 'ethers'
import { ethers } from 'hardhat'
import { getContractFactory } from '@eth-optimism/contracts'
import { MessageStatus } from '@eth-optimism/sdk'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import { withdrawalTest } from './shared/utils'
describe('Bridged tokens', () => {
let env: OptimismEnv
before(async () => {
env = await OptimismEnv.new()
})
let otherWalletL1: Wallet
let otherWalletL2: Wallet
before(async () => {
const other = Wallet.createRandom()
otherWalletL1 = other.connect(env.l1Wallet.provider)
otherWalletL2 = other.connect(env.l2Wallet.provider)
const tx1 = await env.l1Wallet.sendTransaction({
to: otherWalletL1.address,
value: utils.parseEther('0.01'),
})
await tx1.wait()
const tx2 = await env.l2Wallet.sendTransaction({
to: otherWalletL2.address,
value: utils.parseEther('0.01'),
})
await tx2.wait()
})
let L1Factory__ERC20: ContractFactory
let L2Factory__ERC20: ContractFactory
before(async () => {
L1Factory__ERC20 = await ethers.getContractFactory('ERC20', env.l1Wallet)
L2Factory__ERC20 = getContractFactory('L2StandardERC20', env.l2Wallet)
})
// This is one of the only stateful integration tests in which we don't set up a new contract
// before each test. We do this because the test is more of an "actor-based" test where we're
// going through a series of actions and confirming that the actions are performed correctly at
// every step.
let L1__ERC20: Contract
let L2__ERC20: Contract
before(async () => {
// Deploy the L1 ERC20
L1__ERC20 = await L1Factory__ERC20.deploy(1000000, 'OVM Test', 8, 'OVM')
await L1__ERC20.deployed()
// Deploy the L2 ERC20
L2__ERC20 = await L2Factory__ERC20.deploy(
'0x4200000000000000000000000000000000000010',
L1__ERC20.address,
'OVM Test',
'OVM'
)
await L2__ERC20.deployed()
// Approve the L1 ERC20 to spend our money
const tx = await L1__ERC20.approve(
env.messenger.contracts.l1.L1StandardBridge.address,
1000000
)
await tx.wait()
})
it('should deposit tokens into L2', async () => {
await env.messenger.waitForMessageReceipt(
await env.messenger.depositERC20(
L1__ERC20.address,
L2__ERC20.address,
1000
)
)
expect(await L1__ERC20.balanceOf(env.l1Wallet.address)).to.deep.equal(
BigNumber.from(999000)
)
expect(await L2__ERC20.balanceOf(env.l2Wallet.address)).to.deep.equal(
BigNumber.from(1000)
)
})
it('should transfer tokens on L2', async () => {
const tx = await L2__ERC20.transfer(otherWalletL1.address, 500)
await tx.wait()
expect(await L2__ERC20.balanceOf(env.l2Wallet.address)).to.deep.equal(
BigNumber.from(500)
)
expect(await L2__ERC20.balanceOf(otherWalletL2.address)).to.deep.equal(
BigNumber.from(500)
)
})
withdrawalTest(
'should withdraw tokens from L2 to the depositor',
async () => {
const tx = await env.messenger.withdrawERC20(
L1__ERC20.address,
L2__ERC20.address,
500
)
await env.messenger.waitForMessageStatus(
tx,
MessageStatus.READY_FOR_RELAY
)
await env.messenger.finalizeMessage(tx)
await env.messenger.waitForMessageReceipt(tx)
expect(await L1__ERC20.balanceOf(env.l1Wallet.address)).to.deep.equal(
BigNumber.from(999500)
)
expect(await L2__ERC20.balanceOf(env.l2Wallet.address)).to.deep.equal(
BigNumber.from(0)
)
}
)
withdrawalTest(
'should withdraw tokens from L2 to the transfer recipient',
async () => {
const tx = await env.messenger.withdrawERC20(
L1__ERC20.address,
L2__ERC20.address,
500,
{
signer: otherWalletL2,
}
)
await env.messenger.waitForMessageStatus(
tx,
MessageStatus.READY_FOR_RELAY
)
await env.messenger.finalizeMessage(tx)
await env.messenger.waitForMessageReceipt(tx)
expect(await L1__ERC20.balanceOf(otherWalletL1.address)).to.deep.equal(
BigNumber.from(500)
)
expect(await L2__ERC20.balanceOf(otherWalletL2.address)).to.deep.equal(
BigNumber.from(0)
)
}
)
// This test demonstrates that an apparent withdrawal bug is in fact non-existent.
// Specifically, the L2 bridge does not check that the L2 token being burned corresponds
// with the L1 token which is specified for the withdrawal.
withdrawalTest(
'should not allow an arbitrary L2 token to be withdrawn in exchange for a legitimate L1 token',
async () => {
// First deposit some of the L1 token to L2, so that there is something which could be stolen.
await env.messenger.waitForMessageReceipt(
await env.messenger.depositERC20(
L1__ERC20.address,
L2__ERC20.address,
1000
)
)
expect(await L2__ERC20.balanceOf(env.l2Wallet.address)).to.deep.equal(
BigNumber.from(1000)
)
// Deploy a Fake L2 token, which:
// - returns the address of a legitimate L1 token from its l1Token() getter.
// - allows the L2 bridge to call its burn() function.
const fakeToken = await (
await ethers.getContractFactory('FakeL2StandardERC20', env.l2Wallet)
).deploy(
L1__ERC20.address,
env.messenger.contracts.l2.L2StandardBridge.address
)
await fakeToken.deployed()
const balBefore = await L1__ERC20.balanceOf(otherWalletL1.address)
// Withdraw some of the Fake L2 token, hoping to receive the same amount of the legitimate
// token on L1.
const withdrawalTx = await env.messenger.withdrawERC20(
L1__ERC20.address,
fakeToken.address,
500,
{
signer: otherWalletL2,
}
)
await env.messenger.waitForMessageStatus(
withdrawalTx,
MessageStatus.READY_FOR_RELAY
)
await env.messenger.finalizeMessage(withdrawalTx)
await env.messenger.waitForMessageReceipt(withdrawalTx)
// Ensure that the L1 recipient address has not received any additional L1 token balance.
expect(await L1__ERC20.balanceOf(otherWalletL1.address)).to.deep.equal(
balBefore
)
}
)
})
integration-tests/test/contracts.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { BigNumber, Contract, ContractFactory, utils, Wallet } from 'ethers'
import { ethers } from 'hardhat'
import { UniswapV3Deployer } from 'uniswap-v3-deploy-plugin/dist/deployer/UniswapV3Deployer'
import { FeeAmount, TICK_SPACINGS } from '@uniswap/v3-sdk'
import { abi as NFTABI } from '@uniswap/v3-periphery/artifacts/contracts/NonfungiblePositionManager.sol/NonfungiblePositionManager.json'
import { abi as RouterABI } from '@uniswap/v3-periphery/artifacts/contracts/SwapRouter.sol/SwapRouter.json'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
// Below methods taken from the Uniswap test suite, see
// https://github.com/Uniswap/v3-periphery/blob/main/test/shared/ticks.ts
const getMinTick = (tickSpacing: number) =>
Math.ceil(-887272 / tickSpacing) * tickSpacing
const getMaxTick = (tickSpacing: number) =>
Math.floor(887272 / tickSpacing) * tickSpacing
describe('Contract interactions', () => {
let env: OptimismEnv
let Factory__ERC20: ContractFactory
let otherWallet: Wallet
before(async () => {
env = await OptimismEnv.new()
Factory__ERC20 = await ethers.getContractFactory('ERC20', env.l2Wallet)
otherWallet = Wallet.createRandom().connect(env.l2Wallet.provider)
await env.l2Wallet.sendTransaction({
to: otherWallet.address,
value: utils.parseEther('0.1'),
})
})
describe('ERC20s', () => {
let contract: Contract
before(async () => {
Factory__ERC20 = await ethers.getContractFactory('ERC20', env.l2Wallet)
})
it('should successfully deploy the contract', async () => {
contract = await Factory__ERC20.deploy(100000000, 'OVM Test', 8, 'OVM')
await contract.deployed()
})
it('should support approvals', async () => {
const spender = '0x' + '22'.repeat(20)
const tx = await contract.approve(spender, 1000)
await tx.wait()
let allowance = await contract.allowance(env.l2Wallet.address, spender)
expect(allowance).to.deep.equal(BigNumber.from(1000))
allowance = await contract.allowance(otherWallet.address, spender)
expect(allowance).to.deep.equal(BigNumber.from(0))
const logs = await contract.queryFilter(
contract.filters.Approval(env.l2Wallet.address),
1,
'latest'
)
expect(logs[0].args._owner).to.equal(env.l2Wallet.address)
expect(logs[0].args._spender).to.equal(spender)
expect(logs[0].args._value).to.deep.equal(BigNumber.from(1000))
})
it('should support transferring balances', async () => {
const tx = await contract.transfer(otherWallet.address, 1000)
await tx.wait()
const balFrom = await contract.balanceOf(env.l2Wallet.address)
const balTo = await contract.balanceOf(otherWallet.address)
expect(balFrom).to.deep.equal(BigNumber.from(100000000).sub(1000))
expect(balTo).to.deep.equal(BigNumber.from(1000))
const logs = await contract.queryFilter(
contract.filters.Transfer(env.l2Wallet.address),
1,
'latest'
)
expect(logs[0].args._from).to.equal(env.l2Wallet.address)
expect(logs[0].args._to).to.equal(otherWallet.address)
expect(logs[0].args._value).to.deep.equal(BigNumber.from(1000))
})
it('should support being self destructed', async () => {
const tx = await contract.destroy()
await tx.wait()
const code = await env.l2Wallet.provider.getCode(contract.address)
expect(code).to.equal('0x')
})
})
describe('uniswap', () => {
let contracts: { [name: string]: Contract }
let tokens: Contract[]
before(async () => {
if (
process.env.UNISWAP_POSITION_MANAGER_ADDRESS &&
process.env.UNISWAP_ROUTER_ADDRESS
) {
console.log('Using predeployed Uniswap. Addresses:')
console.log(
`Position manager: ${process.env.UNISWAP_POSITION_MANAGER_ADDRESS}`
)
console.log(`Router: ${process.env.UNISWAP_ROUTER_ADDRESS}`)
contracts = {
positionManager: new Contract(
process.env.UNISWAP_POSITION_MANAGER_ADDRESS,
NFTABI
).connect(env.l2Wallet),
router: new Contract(
process.env.UNISWAP_ROUTER_ADDRESS,
RouterABI
).connect(env.l2Wallet),
}
}
const tokenA = await Factory__ERC20.deploy(100000000, 'OVM1', 8, 'OVM1')
await tokenA.deployed()
const tokenB = await Factory__ERC20.deploy(100000000, 'OVM2', 8, 'OVM2')
await tokenB.deployed()
tokens = [tokenA, tokenB]
tokens.sort((a, b) => {
if (a.address > b.address) {
return 1
}
if (a.address < b.address) {
return -1
}
return 0
})
const tx = await tokens[0].transfer(otherWallet.address, 100000)
await tx.wait()
})
it('should deploy the Uniswap ecosystem', async function () {
if (contracts) {
console.log(
'Skipping Uniswap deployment since addresses are already defined.'
)
this.skip()
return
}
contracts = await UniswapV3Deployer.deploy(env.l2Wallet)
})
it('should deploy and initialize a liquidity pool', async () => {
const tx =
await contracts.positionManager.createAndInitializePoolIfNecessary(
tokens[0].address,
tokens[1].address,
FeeAmount.MEDIUM,
// initial ratio of 1/1
BigNumber.from('79228162514264337593543950336')
)
await tx.wait()
})
it('should approve the contracts', async () => {
for (const wallet of [env.l2Wallet, otherWallet]) {
for (const token of tokens) {
let tx = await token
.connect(wallet)
.approve(contracts.positionManager.address, 100000000)
await tx.wait()
tx = await token
.connect(wallet)
.approve(contracts.router.address, 100000000)
await tx.wait()
}
}
})
it('should mint new positions', async () => {
const tx = await contracts.positionManager.mint(
{
token0: tokens[0].address,
token1: tokens[1].address,
tickLower: getMinTick(TICK_SPACINGS[FeeAmount.MEDIUM]),
tickUpper: getMaxTick(TICK_SPACINGS[FeeAmount.MEDIUM]),
fee: FeeAmount.MEDIUM,
recipient: env.l2Wallet.address,
amount0Desired: 15,
amount1Desired: 15,
amount0Min: 0,
amount1Min: 0,
deadline: Date.now() * 2,
},
{
gasLimit: 10000000,
}
)
await tx.wait()
expect(
await contracts.positionManager.balanceOf(env.l2Wallet.address)
).to.eq(1)
expect(
await contracts.positionManager.tokenOfOwnerByIndex(
env.l2Wallet.address,
0
)
).to.eq(1)
})
it('should swap', async () => {
const tx = await contracts.router.connect(otherWallet).exactInputSingle(
{
tokenIn: tokens[0].address,
tokenOut: tokens[1].address,
fee: FeeAmount.MEDIUM,
recipient: otherWallet.address,
deadline: Date.now() * 2,
amountIn: 10,
amountOutMinimum: 0,
sqrtPriceLimitX96: 0,
},
{
gasLimit: 10000000,
}
)
await tx.wait()
expect(await tokens[1].balanceOf(otherWallet.address)).to.deep.equal(
BigNumber.from('5')
)
})
})
})
integration-tests/test/fee-payment.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { BigNumber, utils } from 'ethers'
import { serialize } from '@ethersproject/transactions'
import { predeploys, getContractFactory } from '@eth-optimism/contracts'
/* Imports: Internal */
import { expect } from './shared/setup'
import { hardhatTest, gasPriceOracleWallet } from './shared/utils'
import { OptimismEnv } from './shared/env'
const setPrices = async (env: OptimismEnv, value: number | BigNumber) => {
const gasPrice = await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).setGasPrice(value)
await gasPrice.wait()
const baseFee = await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).setL1BaseFee(value)
await baseFee.wait()
}
describe('Fee Payment Integration Tests', async () => {
let env: OptimismEnv
const other = '0x1234123412341234123412341234123412341234'
before(async () => {
env = await OptimismEnv.new()
})
hardhatTest(
`should return eth_gasPrice equal to OVM_GasPriceOracle.gasPrice`,
async () => {
const assertGasPrice = async () => {
const gasPrice = await env.l2Wallet.getGasPrice()
const oracleGasPrice =
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).gasPrice()
expect(gasPrice).to.deep.equal(oracleGasPrice)
}
await assertGasPrice()
// update the gas price
const tx = await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).setGasPrice(1000)
await tx.wait()
await assertGasPrice()
}
)
hardhatTest('Paying a nonzero but acceptable gasPrice fee', async () => {
await setPrices(env, 1000)
const amount = utils.parseEther('0.0000001')
const balanceBefore = await env.l2Wallet.getBalance()
const feeVaultBalanceBefore = await env.l2Wallet.provider.getBalance(
env.messenger.contracts.l2.OVM_SequencerFeeVault.address
)
expect(balanceBefore.gt(amount))
const unsigned = await env.l2Wallet.populateTransaction({
to: other,
value: amount,
gasLimit: 500000,
})
const raw = serialize({
nonce: parseInt(unsigned.nonce.toString(10), 10),
value: unsigned.value,
gasPrice: unsigned.gasPrice,
gasLimit: unsigned.gasLimit,
to: unsigned.to,
data: unsigned.data,
})
const l1Fee = await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).getL1Fee(raw)
const tx = await env.l2Wallet.sendTransaction(unsigned)
const receipt = await tx.wait()
expect(receipt.status).to.eq(1)
const balanceAfter = await env.l2Wallet.getBalance()
const feeVaultBalanceAfter = await env.l2Wallet.provider.getBalance(
env.messenger.contracts.l2.OVM_SequencerFeeVault.address
)
const l2Fee = receipt.gasUsed.mul(tx.gasPrice)
const expectedFeePaid = l1Fee.add(l2Fee)
expect(balanceBefore.sub(balanceAfter)).to.deep.equal(
expectedFeePaid.add(amount)
)
// Make sure the fee was transferred to the vault.
expect(feeVaultBalanceAfter.sub(feeVaultBalanceBefore)).to.deep.equal(
expectedFeePaid
)
await setPrices(env, 1)
})
hardhatTest('should compute correct fee', async () => {
await setPrices(env, 1000)
const preBalance = await env.l2Wallet.getBalance()
const OVM_GasPriceOracle = getContractFactory('OVM_GasPriceOracle')
.attach(predeploys.OVM_GasPriceOracle)
.connect(env.l2Wallet)
const WETH = getContractFactory('OVM_ETH')
.attach(predeploys.OVM_ETH)
.connect(env.l2Wallet)
const feeVaultBefore = await WETH.balanceOf(
predeploys.OVM_SequencerFeeVault
)
const unsigned = await env.l2Wallet.populateTransaction({
to: env.l2Wallet.address,
value: 0,
})
const raw = serialize({
nonce: parseInt(unsigned.nonce.toString(10), 10),
value: unsigned.value,
gasPrice: unsigned.gasPrice,
gasLimit: unsigned.gasLimit,
to: unsigned.to,
data: unsigned.data,
})
const l1Fee = await OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).getL1Fee(raw)
const tx = await env.l2Wallet.sendTransaction(unsigned)
const receipt = await tx.wait()
const l2Fee = receipt.gasUsed.mul(tx.gasPrice)
const postBalance = await env.l2Wallet.getBalance()
const feeVaultAfter = await WETH.balanceOf(predeploys.OVM_SequencerFeeVault)
const fee = l1Fee.add(l2Fee)
const balanceDiff = preBalance.sub(postBalance)
const feeReceived = feeVaultAfter.sub(feeVaultBefore)
expect(balanceDiff).to.deep.equal(fee)
// There is no inflation
expect(feeReceived).to.deep.equal(balanceDiff)
await setPrices(env, 1)
})
it('should not be able to withdraw fees before the minimum is met', async () => {
await expect(env.messenger.contracts.l2.OVM_SequencerFeeVault.withdraw()).to
.be.rejected
})
hardhatTest(
'should be able to withdraw fees back to L1 once the minimum is met',
async () => {
const l1FeeWallet =
await env.messenger.contracts.l2.OVM_SequencerFeeVault.l1FeeWallet()
const balanceBefore = await env.l1Wallet.provider.getBalance(l1FeeWallet)
const withdrawalAmount =
await env.messenger.contracts.l2.OVM_SequencerFeeVault.MIN_WITHDRAWAL_AMOUNT()
// Transfer the minimum required to withdraw.
const tx = await env.l2Wallet.sendTransaction({
to: env.messenger.contracts.l2.OVM_SequencerFeeVault.address,
value: withdrawalAmount,
gasLimit: 500000,
})
await tx.wait()
const vaultBalance = await env.messenger.contracts.l2.OVM_ETH.balanceOf(
env.messenger.contracts.l2.OVM_SequencerFeeVault.address
)
const withdrawTx =
await env.messenger.contracts.l2.OVM_SequencerFeeVault.withdraw()
// Wait for the withdrawal to be relayed to L1.
await withdrawTx.wait()
await env.relayXDomainMessages(withdrawTx)
await env.waitForXDomainTransaction(withdrawTx)
// Balance difference should be equal to old L2 balance.
const balanceAfter = await env.l1Wallet.provider.getBalance(l1FeeWallet)
expect(balanceAfter.sub(balanceBefore)).to.deep.equal(
BigNumber.from(vaultBalance)
)
}
)
})
integration-tests/test/hardfork.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { Contract, BigNumber } from 'ethers'
import { ethers } from 'hardhat'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
export const traceToGasByOpcode = (structLogs, opcode) => {
let gas = 0
const opcodes = []
for (const log of structLogs) {
if (log.op === opcode) {
opcodes.push(opcode)
gas += log.gasCost
}
}
return gas
}
describe('Hard forks', () => {
let env: OptimismEnv
let SimpleStorage: Contract
let SelfDestruction: Contract
let Precompiles: Contract
before(async () => {
env = await OptimismEnv.new()
const Factory__SimpleStorage = await ethers.getContractFactory(
'SimpleStorage',
env.l2Wallet
)
SimpleStorage = await Factory__SimpleStorage.deploy()
const Factory__SelfDestruction = await ethers.getContractFactory(
'SelfDestruction',
env.l2Wallet
)
SelfDestruction = await Factory__SelfDestruction.deploy()
const Factory__Precompiles = await ethers.getContractFactory(
'Precompiles',
env.l2Wallet
)
Precompiles = await Factory__Precompiles.deploy()
})
describe('Berlin', () => {
// https://eips.ethereum.org/EIPS/eip-2929
describe('EIP-2929', () => {
it('should update the gas schedule', async () => {
// Get the tip height
const tip = await env.l2Provider.getBlock('latest')
// send a transaction to be able to trace
const tx = await SimpleStorage.setValueNotXDomain(
`0x${'77'.repeat(32)}`
)
await tx.wait()
// Collect the traces
const berlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash]
)
const preBerlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash, { overrides: { berlinBlock: tip.number * 2 } }]
)
expect(berlinTrace.gas).to.not.eq(preBerlinTrace.gas)
const berlinSstoreCosts = traceToGasByOpcode(
berlinTrace.structLogs,
'SSTORE'
)
const preBerlinSstoreCosts = traceToGasByOpcode(
preBerlinTrace.structLogs,
'SSTORE'
)
expect(berlinSstoreCosts).to.not.eq(preBerlinSstoreCosts)
})
})
// https://eips.ethereum.org/EIPS/eip-2565
describe('EIP-2565', async () => {
it('should become cheaper', async () => {
const tip = await env.l2Provider.getBlock('latest')
const tx = await Precompiles.expmod(64, 1, 64, { gasLimit: 5_000_000 })
await tx.wait()
const berlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash]
)
const preBerlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash, { overrides: { berlinBlock: tip.number * 2 } }]
)
expect(berlinTrace.gas).to.be.lt(preBerlinTrace.gas)
})
})
})
// Optimism includes EIP-3529 as part of its Berlin hardfork. It is part
// of the London hardfork on L1. Since it is coupled to the Berlin
// hardfork, some of its functionality cannot be directly tests via
// integration tests since we can currently only turn on all of the Berlin
// EIPs or none of the Berlin EIPs
describe('Berlin Additional (L1 London)', () => {
// https://eips.ethereum.org/EIPS/eip-3529
describe('EIP-3529', async () => {
const bytes32Zero = '0x' + '00'.repeat(32)
const bytes32NonZero = '0x' + 'ff'.repeat(32)
it('should lower the refund for storage clear', async () => {
const tip = await env.l2Provider.getBlock('latest')
const value = await SelfDestruction.callStatic.data()
// It should be non zero
expect(BigNumber.from(value).toNumber()).to.not.eq(0)
{
// Set the value to another non zero value
// Going from non zero to non zero
const tx = await SelfDestruction.setData(bytes32NonZero, {
gasLimit: 5_000_000,
})
await tx.wait()
const berlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash]
)
const preBerlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash, { overrides: { berlinBlock: tip.number * 2 } }]
)
// Updating a non zero value to another non zero value should not change
expect(berlinTrace.gas).to.deep.eq(preBerlinTrace.gas)
}
{
// Set the value to the zero value
// Going from non zero to zero
const tx = await SelfDestruction.setData(bytes32Zero, {
gasLimit: 5_000_000,
})
await tx.wait()
const berlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash]
)
const preBerlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash, { overrides: { berlinBlock: tip.number * 2 } }]
)
// Updating to a zero value from a non zero value should becomes
// more expensive due to this change being coupled with EIP-2929
expect(berlinTrace.gas).to.be.gt(preBerlinTrace.gas)
}
{
// Set the value to a non zero value
// Going from zero to non zero
const tx = await SelfDestruction.setData(bytes32NonZero, {
gasLimit: 5_000_000,
})
await tx.wait()
const berlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash]
)
const preBerlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash, { overrides: { berlinBlock: tip.number * 2 } }]
)
// Updating to a zero value from a non zero value should becomes
// more expensive due to this change being coupled with EIP-2929
expect(berlinTrace.gas).to.be.gt(preBerlinTrace.gas)
}
})
it('should remove the refund for selfdestruct', async () => {
const tip = await env.l2Provider.getBlock('latest')
// Send transaction with a large gas limit
const tx = await SelfDestruction.destruct({ gasLimit: 5_000_000 })
await tx.wait()
const berlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash]
)
const preBerlinTrace = await env.l2Provider.send(
'debug_traceTransaction',
[tx.hash, { overrides: { berlinBlock: tip.number * 2 } }]
)
// The berlin execution should use more gas than the pre Berlin
// execution because there is no longer a selfdestruct gas
// refund
expect(berlinTrace.gas).to.be.gt(preBerlinTrace.gas)
})
})
})
})
integration-tests/test/healthcheck.spec.ts deleted 100644 → 0
View file @ cccce791
import fetch from 'node-fetch'
import { expect } from './shared/setup'
import { envConfig } from './shared/utils'
describe('Healthcheck Tests', () => {
before(async function () {
if (!envConfig.RUN_HEALTHCHECK_TESTS) {
this.skip()
}
})
// Super simple test, is the metric server up?
it('should have metrics exposed', async () => {
const response = await fetch(envConfig.HEALTHCHECK_URL)
expect(response.status).to.equal(200)
})
})
integration-tests/test/native-eth-ovm-calls.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { BigNumber, Contract, ContractFactory, Wallet } from 'ethers'
import { ethers } from 'hardhat'
/* Imports: Internal */
import { expect } from './shared/setup'
import {
fundUser,
encodeSolidityRevertMessage,
gasPriceForL2,
} from './shared/utils'
import { OptimismEnv } from './shared/env'
describe('Native ETH value integration tests', () => {
let env: OptimismEnv
let wallet: Wallet
let other: Wallet
before(async () => {
env = await OptimismEnv.new()
wallet = env.l2Wallet
other = Wallet.createRandom().connect(wallet.provider)
})
it('should allow an L2 EOA to send to a new account and back again', async () => {
const getBalances = async (): Promise<BigNumber[]> => {
return [
await wallet.provider.getBalance(wallet.address),
await wallet.provider.getBalance(other.address),
]
}
const expectBalancesWithinRange = (
bal: BigNumber,
lte: BigNumber,
gte: BigNumber
) => {
expect(bal.lte(lte)).to.be.true
expect(bal.gte(gte)).to.be.true
}
const value = ethers.utils.parseEther('0.01')
await fundUser(env.messenger, value, wallet.address)
const initialBalances = await getBalances()
const there = await wallet.sendTransaction({
to: other.address,
value,
gasPrice: await gasPriceForL2(),
})
const thereReceipt = await there.wait()
const thereGas = thereReceipt.gasUsed.mul(there.gasPrice)
const thereBalances = await getBalances()
const thereWithGas = initialBalances[0].sub(value).sub(thereGas).sub(100000)
expectBalancesWithinRange(
thereBalances[0],
initialBalances[0].sub(value),
thereWithGas
)
expect(initialBalances[1].add(value).eq(thereBalances[1]))
const backVal = ethers.utils.parseEther('0.005')
const backAgain = await other.sendTransaction({
to: wallet.address,
value: backVal,
gasPrice: await gasPriceForL2(),
})
const backReceipt = await backAgain.wait()
const backGas = backReceipt.gasUsed.mul(backAgain.gasPrice)
const backBalances = await getBalances()
expectBalancesWithinRange(
backBalances[0],
initialBalances[0].sub(thereGas).sub(backVal),
initialBalances[0].sub(thereGas).sub(backVal).sub(200000)
)
expectBalancesWithinRange(
backBalances[1],
initialBalances[1].add(backVal).sub(backGas),
initialBalances[1].add(backVal).sub(backGas).sub(200000)
)
})
describe(`calls between OVM contracts with native ETH value and relevant opcodes`, async () => {
const initialBalance0 = 42000
let Factory__ValueCalls: ContractFactory
let ValueCalls0: Contract
let ValueCalls1: Contract
const checkBalances = async (expectedBalances: number[]) => {
// query geth as one check
const balance0 = await wallet.provider.getBalance(ValueCalls0.address)
const balance1 = await wallet.provider.getBalance(ValueCalls1.address)
expect(balance0).to.deep.eq(BigNumber.from(expectedBalances[0]))
expect(balance1).to.deep.eq(BigNumber.from(expectedBalances[1]))
// query ovmBALANCE() opcode via eth_call as another check
const ovmBALANCE0 = await ValueCalls0.callStatic.getBalance(
ValueCalls0.address
)
const ovmBALANCE1 = await ValueCalls0.callStatic.getBalance(
ValueCalls1.address
)
expect(ovmBALANCE0).to.deep.eq(
BigNumber.from(expectedBalances[0]),
'geth RPC does not match ovmBALANCE'
)
expect(ovmBALANCE1).to.deep.eq(
BigNumber.from(expectedBalances[1]),
'geth RPC does not match ovmBALANCE'
)
// query ovmSELFBALANCE() opcode via eth_call as another check
const ovmSELFBALANCE0 = await ValueCalls0.callStatic.getSelfBalance()
const ovmSELFBALANCE1 = await ValueCalls1.callStatic.getSelfBalance()
expect(ovmSELFBALANCE0).to.deep.eq(
BigNumber.from(expectedBalances[0]),
'geth RPC does not match ovmSELFBALANCE'
)
expect(ovmSELFBALANCE1).to.deep.eq(
BigNumber.from(expectedBalances[1]),
'geth RPC does not match ovmSELFBALANCE'
)
// query ovmSELFBALANCE() opcode via eth_call as another check
const ovmEthBalanceOf0 =
await env.messenger.contracts.l2.OVM_ETH.balanceOf(ValueCalls0.address)
const ovmEthBalanceOf1 =
await env.messenger.contracts.l2.OVM_ETH.balanceOf(ValueCalls1.address)
expect(ovmEthBalanceOf0).to.deep.eq(
BigNumber.from(expectedBalances[0]),
'geth RPC does not match OVM_ETH.balanceOf'
)
expect(ovmEthBalanceOf1).to.deep.eq(
BigNumber.from(expectedBalances[1]),
'geth RPC does not match OVM_ETH.balanceOf'
)
// query address(this).balance solidity via eth_call as final check
const ovmAddressThisBalance0 =
await ValueCalls0.callStatic.getAddressThisBalance()
const ovmAddressThisBalance01 =
await ValueCalls1.callStatic.getAddressThisBalance()
expect(ovmAddressThisBalance0).to.deep.eq(
BigNumber.from(expectedBalances[0]),
'geth RPC does not match address(this).balance'
)
expect(ovmAddressThisBalance01).to.deep.eq(
BigNumber.from(expectedBalances[1]),
'geth RPC does not match address(this).balance'
)
}
before(async () => {
Factory__ValueCalls = await ethers.getContractFactory(
'ValueCalls',
wallet
)
})
beforeEach(async () => {
ValueCalls0 = await Factory__ValueCalls.deploy()
ValueCalls1 = await Factory__ValueCalls.deploy()
await fundUser(env.messenger, initialBalance0, ValueCalls0.address)
// These tests ass assume ValueCalls0 starts with a balance, but ValueCalls1 does not.
await checkBalances([initialBalance0, 0])
})
it('should allow ETH to be sent', async () => {
const sendAmount = 15
const tx = await ValueCalls0.simpleSend(ValueCalls1.address, sendAmount, {
gasPrice: await gasPriceForL2(),
})
await tx.wait()
await checkBalances([initialBalance0 - sendAmount, sendAmount])
})
it('should revert if a function is nonpayable', async () => {
const sendAmount = 15
const [success, returndata] = await ValueCalls0.callStatic.sendWithData(
ValueCalls1.address,
sendAmount,
ValueCalls1.interface.encodeFunctionData('nonPayable')
)
expect(success).to.be.false
expect(returndata).to.eq('0x')
})
it('should allow ETH to be sent and have the correct ovmCALLVALUE', async () => {
const sendAmount = 15
const [success, returndata] = await ValueCalls0.callStatic.sendWithData(
ValueCalls1.address,
sendAmount,
ValueCalls1.interface.encodeFunctionData('getCallValue')
)
expect(success).to.be.true
expect(BigNumber.from(returndata)).to.deep.eq(BigNumber.from(sendAmount))
})
it('should have the correct ovmSELFBALANCE which includes the msg.value', async () => {
// give an initial balance which the ovmCALLVALUE should be added to when calculating ovmSELFBALANCE
const initialBalance = 10
await fundUser(env.messenger, initialBalance, ValueCalls1.address)
const sendAmount = 15
const [success, returndata] = await ValueCalls0.callStatic.sendWithData(
ValueCalls1.address,
sendAmount,
ValueCalls1.interface.encodeFunctionData('getSelfBalance')
)
expect(success).to.be.true
expect(BigNumber.from(returndata)).to.deep.eq(
BigNumber.from(initialBalance + sendAmount)
)
})
it('should have the correct callvalue but not persist the transfer if the target reverts', async () => {
const sendAmount = 15
const internalCalldata = ValueCalls1.interface.encodeFunctionData(
'verifyCallValueAndRevert',
[sendAmount]
)
const [success, returndata] = await ValueCalls0.callStatic.sendWithData(
ValueCalls1.address,
sendAmount,
internalCalldata
)
expect(success).to.be.false
expect(returndata).to.eq(encodeSolidityRevertMessage('expected revert'))
await checkBalances([initialBalance0, 0])
})
it('should look like the subcall reverts with no data if value exceeds balance', async () => {
const sendAmount = initialBalance0 + 1
const internalCalldata = ValueCalls1.interface.encodeFunctionData(
'verifyCallValueAndReturn',
[sendAmount] // this would be correct and return successfuly, IF it could get here
)
const [success, returndata] = await ValueCalls0.callStatic.sendWithData(
ValueCalls1.address,
sendAmount,
internalCalldata
)
expect(success).to.be.false
expect(returndata).to.eq('0x')
})
it('should preserve msg.value through ovmDELEGATECALLs', async () => {
const Factory__ValueContext = await ethers.getContractFactory(
'ValueContext',
wallet
)
const ValueContext = await Factory__ValueContext.deploy()
await ValueContext.deployTransaction.wait()
const sendAmount = 10
const [outerSuccess, outerReturndata] =
await ValueCalls0.callStatic.sendWithData(
ValueCalls1.address,
sendAmount,
ValueCalls1.interface.encodeFunctionData('delegateCallToCallValue', [
ValueContext.address,
])
)
const [innerSuccess, innerReturndata] =
ValueCalls1.interface.decodeFunctionResult(
'delegateCallToCallValue',
outerReturndata
)
const delegatedOvmCALLVALUE = ValueContext.interface.decodeFunctionResult(
'getCallValue',
innerReturndata
)[0]
expect(outerSuccess).to.be.true
expect(innerSuccess).to.be.true
expect(delegatedOvmCALLVALUE).to.deep.eq(BigNumber.from(sendAmount))
})
it('should have correct address(this).balance through ovmDELEGATECALLs to another account', async () => {
const Factory__ValueContext = await ethers.getContractFactory(
'ValueContext',
wallet
)
const ValueContext = await Factory__ValueContext.deploy()
await ValueContext.deployTransaction.wait()
const [delegatedSuccess, delegatedReturndata] =
await ValueCalls0.callStatic.delegateCallToAddressThisBalance(
ValueContext.address
)
expect(delegatedSuccess).to.be.true
expect(delegatedReturndata).to.deep.eq(BigNumber.from(initialBalance0))
})
it('should have correct address(this).balance through ovmDELEGATECALLs to same account', async () => {
const [delegatedSuccess, delegatedReturndata] =
await ValueCalls0.callStatic.delegateCallToAddressThisBalance(
ValueCalls0.address
)
expect(delegatedSuccess).to.be.true
expect(delegatedReturndata).to.deep.eq(BigNumber.from(initialBalance0))
})
it('should allow delegate calls which preserve msg.value even with no balance going into the inner call', async () => {
const Factory__SendETHAwayAndDelegateCall: ContractFactory =
await ethers.getContractFactory('SendETHAwayAndDelegateCall', wallet)
const SendETHAwayAndDelegateCall: Contract =
await Factory__SendETHAwayAndDelegateCall.deploy()
await SendETHAwayAndDelegateCall.deployTransaction.wait()
const value = 17
const [delegatedSuccess, delegatedReturndata] =
await SendETHAwayAndDelegateCall.callStatic.emptySelfAndDelegateCall(
ValueCalls0.address,
ValueCalls0.interface.encodeFunctionData('getCallValue'),
{
value,
}
)
expect(delegatedSuccess).to.be.true
expect(delegatedReturndata).to.deep.eq(BigNumber.from(value))
})
})
})
integration-tests/test/native-eth.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { Wallet, utils, BigNumber } from 'ethers'
import { serialize } from '@ethersproject/transactions'
import { predeploys } from '@eth-optimism/contracts'
import { expectApprox } from '@eth-optimism/core-utils'
/* Imports: Internal */
import { expect } from './shared/setup'
import {
DEFAULT_TEST_GAS_L1,
DEFAULT_TEST_GAS_L2,
envConfig,
withdrawalTest,
gasPriceOracleWallet,
} from './shared/utils'
import { OptimismEnv } from './shared/env'
// TX size enforced by CTC:
const MAX_ROLLUP_TX_SIZE = 50_000
describe('Native ETH Integration Tests', async () => {
let env: OptimismEnv
let l1Bob: Wallet
let l2Bob: Wallet
const getBalances = async (_env: OptimismEnv) => {
const l1UserBalance = await _env.l1Wallet.getBalance()
const l2UserBalance = await _env.l2Wallet.getBalance()
const l1BobBalance = await l1Bob.getBalance()
const l2BobBalance = await l2Bob.getBalance()
const l1BridgeBalance = await _env.l1Wallet.provider.getBalance(
_env.messenger.contracts.l1.L1StandardBridge.address
)
return {
l1UserBalance,
l2UserBalance,
l1BobBalance,
l2BobBalance,
l1BridgeBalance,
}
}
before(async () => {
env = await OptimismEnv.new()
l1Bob = Wallet.createRandom().connect(env.l1Wallet.provider)
l2Bob = l1Bob.connect(env.l2Wallet.provider)
})
describe('estimateGas', () => {
it('Should estimate gas for ETH withdraw', async () => {
const amount = utils.parseEther('0.0000001')
const gas =
await env.messenger.contracts.l2.L2StandardBridge.estimateGas.withdraw(
predeploys.OVM_ETH,
amount,
0,
'0xFFFF'
)
// Expect gas to be less than or equal to the target plus 1%
expectApprox(gas, 6700060, { absoluteUpperDeviation: 1000 })
})
})
it('receive', async () => {
const depositAmount = 10
const preBalances = await getBalances(env)
const { tx, receipt } = await env.waitForXDomainTransaction(
env.l1Wallet.sendTransaction({
to: env.messenger.contracts.l1.L1StandardBridge.address,
value: depositAmount,
gasLimit: DEFAULT_TEST_GAS_L1,
})
)
const l1FeePaid = receipt.gasUsed.mul(tx.gasPrice)
const postBalances = await getBalances(env)
expect(postBalances.l1BridgeBalance).to.deep.eq(
preBalances.l1BridgeBalance.add(depositAmount)
)
expect(postBalances.l2UserBalance).to.deep.eq(
preBalances.l2UserBalance.add(depositAmount)
)
expect(postBalances.l1UserBalance).to.deep.eq(
preBalances.l1UserBalance.sub(l1FeePaid.add(depositAmount))
)
})
it('depositETH', async () => {
const depositAmount = 10
const preBalances = await getBalances(env)
const { tx, receipt } = await env.waitForXDomainTransaction(
env.messenger.contracts.l1.L1StandardBridge.depositETH(
DEFAULT_TEST_GAS_L2,
'0xFFFF',
{
value: depositAmount,
gasLimit: DEFAULT_TEST_GAS_L1,
}
)
)
const l1FeePaid = receipt.gasUsed.mul(tx.gasPrice)
const postBalances = await getBalances(env)
expect(postBalances.l1BridgeBalance).to.deep.eq(
preBalances.l1BridgeBalance.add(depositAmount)
)
expect(postBalances.l2UserBalance).to.deep.eq(
preBalances.l2UserBalance.add(depositAmount)
)
expect(postBalances.l1UserBalance).to.deep.eq(
preBalances.l1UserBalance.sub(l1FeePaid.add(depositAmount))
)
})
it('depositETHTo', async () => {
const depositAmount = 10
const preBalances = await getBalances(env)
const depositReceipts = await env.waitForXDomainTransaction(
env.messenger.contracts.l1.L1StandardBridge.depositETHTo(
l2Bob.address,
DEFAULT_TEST_GAS_L2,
'0xFFFF',
{
value: depositAmount,
gasLimit: DEFAULT_TEST_GAS_L1,
}
)
)
const l1FeePaid = depositReceipts.receipt.gasUsed.mul(
depositReceipts.tx.gasPrice
)
const postBalances = await getBalances(env)
expect(postBalances.l1BridgeBalance).to.deep.eq(
preBalances.l1BridgeBalance.add(depositAmount)
)
expect(postBalances.l2BobBalance).to.deep.eq(
preBalances.l2BobBalance.add(depositAmount)
)
expect(postBalances.l1UserBalance).to.deep.eq(
preBalances.l1UserBalance.sub(l1FeePaid.add(depositAmount))
)
})
it('deposit passes with a large data argument', async () => {
const ASSUMED_L2_GAS_LIMIT = 8_000_000
const depositAmount = 10
const preBalances = await getBalances(env)
// Set data length slightly less than MAX_ROLLUP_TX_SIZE
// to allow for encoding and other arguments
const data = `0x` + 'ab'.repeat(MAX_ROLLUP_TX_SIZE - 500)
const { tx, receipt } = await env.waitForXDomainTransaction(
env.messenger.contracts.l1.L1StandardBridge.depositETH(
ASSUMED_L2_GAS_LIMIT,
data,
{
value: depositAmount,
gasLimit: 4_000_000,
}
)
)
const l1FeePaid = receipt.gasUsed.mul(tx.gasPrice)
const postBalances = await getBalances(env)
expect(postBalances.l1BridgeBalance).to.deep.eq(
preBalances.l1BridgeBalance.add(depositAmount)
)
expect(postBalances.l2UserBalance).to.deep.eq(
preBalances.l2UserBalance.add(depositAmount)
)
expect(postBalances.l1UserBalance).to.deep.eq(
preBalances.l1UserBalance.sub(l1FeePaid.add(depositAmount))
)
})
it('depositETH fails with a TOO large data argument', async () => {
const depositAmount = 10
const data = `0x` + 'ab'.repeat(MAX_ROLLUP_TX_SIZE + 1)
await expect(
env.messenger.contracts.l1.L1StandardBridge.depositETH(
DEFAULT_TEST_GAS_L2,
data,
{
value: depositAmount,
}
)
).to.be.reverted
})
withdrawalTest('withdraw', async () => {
const withdrawAmount = BigNumber.from(3)
const preBalances = await getBalances(env)
expect(
preBalances.l2UserBalance.gt(0),
'Cannot run withdrawal test before any deposits...'
)
const transaction =
await env.messenger.contracts.l2.L2StandardBridge.withdraw(
predeploys.OVM_ETH,
withdrawAmount,
DEFAULT_TEST_GAS_L2,
'0xFFFF'
)
await transaction.wait()
await env.relayXDomainMessages(transaction)
const receipts = await env.waitForXDomainTransaction(transaction)
const fee = receipts.tx.gasLimit.mul(receipts.tx.gasPrice)
const postBalances = await getBalances(env)
// Approximate because there's a fee related to relaying the L2 => L1 message and it throws off the math.
expectApprox(
postBalances.l1BridgeBalance,
preBalances.l1BridgeBalance.sub(withdrawAmount),
{ percentUpperDeviation: 1 }
)
expectApprox(
postBalances.l2UserBalance,
preBalances.l2UserBalance.sub(withdrawAmount.add(fee)),
{ percentUpperDeviation: 1 }
)
expectApprox(
postBalances.l1UserBalance,
preBalances.l1UserBalance.add(withdrawAmount),
{ percentUpperDeviation: 1 }
)
})
withdrawalTest('withdrawTo', async () => {
const withdrawAmount = BigNumber.from(3)
const preBalances = await getBalances(env)
expect(
preBalances.l2UserBalance.gt(0),
'Cannot run withdrawal test before any deposits...'
)
const transaction =
await env.messenger.contracts.l2.L2StandardBridge.withdrawTo(
predeploys.OVM_ETH,
l1Bob.address,
withdrawAmount,
DEFAULT_TEST_GAS_L2,
'0xFFFF'
)
await transaction.wait()
await env.relayXDomainMessages(transaction)
const receipts = await env.waitForXDomainTransaction(transaction)
const l2Fee = receipts.tx.gasPrice.mul(receipts.receipt.gasUsed)
// Calculate the L1 portion of the fee
const raw = serialize({
nonce: transaction.nonce,
value: transaction.value,
gasPrice: transaction.gasPrice,
gasLimit: transaction.gasLimit,
to: transaction.to,
data: transaction.data,
})
const l1Fee = await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).getL1Fee(raw)
const fee = l2Fee.add(l1Fee)
const postBalances = await getBalances(env)
expect(postBalances.l1BridgeBalance).to.deep.eq(
preBalances.l1BridgeBalance.sub(withdrawAmount),
'L1 Bridge Balance Mismatch'
)
expect(postBalances.l2UserBalance).to.deep.eq(
preBalances.l2UserBalance.sub(withdrawAmount.add(fee)),
'L2 User Balance Mismatch'
)
expect(postBalances.l1BobBalance).to.deep.eq(
preBalances.l1BobBalance.add(withdrawAmount),
'L1 User Balance Mismatch'
)
})
withdrawalTest(
'deposit, transfer, withdraw',
async () => {
// 1. deposit
const amount = utils.parseEther('1')
await env.waitForXDomainTransaction(
env.messenger.contracts.l1.L1StandardBridge.depositETH(
DEFAULT_TEST_GAS_L2,
'0xFFFF',
{
value: amount,
gasLimit: DEFAULT_TEST_GAS_L1,
}
)
)
// 2. transfer to another address
const other = Wallet.createRandom().connect(env.l2Wallet.provider)
const tx = await env.l2Wallet.sendTransaction({
to: other.address,
value: amount,
})
await tx.wait()
const l1BalanceBefore = await other
.connect(env.l1Wallet.provider)
.getBalance()
// 3. do withdrawal
const withdrawnAmount = utils.parseEther('0.95')
const transaction =
await env.messenger.contracts.l2.L2StandardBridge.connect(
other
).withdraw(
predeploys.OVM_ETH,
withdrawnAmount,
DEFAULT_TEST_GAS_L1,
'0xFFFF'
)
await transaction.wait()
await env.relayXDomainMessages(transaction)
const receipts = await env.waitForXDomainTransaction(transaction)
// Compute the L1 portion of the fee
const l1Fee =
await await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).getL1Fee(
serialize({
nonce: transaction.nonce,
value: transaction.value,
gasPrice: transaction.gasPrice,
gasLimit: transaction.gasLimit,
to: transaction.to,
data: transaction.data,
})
)
// check that correct amount was withdrawn and that fee was charged
const l2Fee = receipts.tx.gasPrice.mul(receipts.receipt.gasUsed)
const fee = l1Fee.add(l2Fee)
const l1BalanceAfter = await other
.connect(env.l1Wallet.provider)
.getBalance()
const l2BalanceAfter = await other.getBalance()
expect(l1BalanceAfter).to.deep.eq(l1BalanceBefore.add(withdrawnAmount))
expect(l2BalanceAfter).to.deep.eq(amount.sub(withdrawnAmount).sub(fee))
},
envConfig.MOCHA_TIMEOUT * 3
)
})
integration-tests/test/nft-bridge.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { Contract, ContractFactory, utils, Wallet } from 'ethers'
import { ethers } from 'hardhat'
import { getChainId } from '@eth-optimism/core-utils'
import { predeploys } from '@eth-optimism/contracts'
import Artifact__TestERC721 from '@eth-optimism/contracts-periphery/artifacts/contracts/testing/helpers/TestERC721.sol/TestERC721.json'
import Artifact__L1ERC721Bridge from '@eth-optimism/contracts-bedrock/artifacts/contracts/L1/L1ERC721Bridge.sol/L1ERC721Bridge.json'
import Artifact__L2ERC721Bridge from '@eth-optimism/contracts-bedrock/artifacts/contracts/L2/L2ERC721Bridge.sol/L2ERC721Bridge.json'
import Artifact__OptimismMintableERC721Factory from '@eth-optimism/contracts-bedrock/artifacts/contracts/universal/OptimismMintableERC721Factory.sol/OptimismMintableERC721Factory.json'
import Artifact__OptimismMintableERC721 from '@eth-optimism/contracts-bedrock/artifacts/contracts/universal/OptimismMintableERC721.sol/OptimismMintableERC721.json'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import { withdrawalTest } from './shared/utils'
const TOKEN_ID: number = 1
const FINALIZATION_GAS: number = 600_000
const NON_NULL_BYTES: string = '0x1111'
describe('ERC721 Bridge', () => {
let env: OptimismEnv
before(async () => {
env = await OptimismEnv.new()
})
let aliceWalletL1: Wallet
let aliceWalletL2: Wallet
let aliceAddress: string
let bobWalletL1: Wallet
let bobWalletL2: Wallet
let bobAddress: string
before(async () => {
const alice = Wallet.createRandom()
aliceWalletL1 = alice.connect(env.l1Wallet.provider)
aliceWalletL2 = alice.connect(env.l2Wallet.provider)
aliceAddress = aliceWalletL1.address
const tx = await env.l2Wallet.sendTransaction({
to: aliceAddress,
value: utils.parseEther('0.01'),
})
await tx.wait()
bobWalletL1 = env.l1Wallet
bobWalletL2 = env.l2Wallet
bobAddress = env.l1Wallet.address
})
let Factory__L1ERC721: ContractFactory
let Factory__L1ERC721Bridge: ContractFactory
let Factory__L2ERC721Bridge: ContractFactory
let Factory__OptimismMintableERC721Factory: ContractFactory
before(async () => {
Factory__L1ERC721 = await ethers.getContractFactory(
Artifact__TestERC721.abi,
Artifact__TestERC721.bytecode,
bobWalletL1
)
Factory__L1ERC721Bridge = await ethers.getContractFactory(
Artifact__L1ERC721Bridge.abi,
Artifact__L1ERC721Bridge.bytecode,
bobWalletL1
)
Factory__L2ERC721Bridge = await ethers.getContractFactory(
Artifact__L2ERC721Bridge.abi,
Artifact__L2ERC721Bridge.bytecode,
bobWalletL2
)
Factory__OptimismMintableERC721Factory = await ethers.getContractFactory(
Artifact__OptimismMintableERC721Factory.abi,
Artifact__OptimismMintableERC721Factory.bytecode,
bobWalletL2
)
})
let L1ERC721: Contract
let L1ERC721Bridge: Contract
let L2ERC721Bridge: Contract
let OptimismMintableERC721Factory: Contract
let OptimismMintableERC721: Contract
beforeEach(async () => {
L1ERC721 = await Factory__L1ERC721.deploy()
await L1ERC721.deployed()
L1ERC721Bridge = await Factory__L1ERC721Bridge.deploy(
env.messenger.contracts.l1.L1CrossDomainMessenger.address,
ethers.utils.getContractAddress({
from: await Factory__L2ERC721Bridge.signer.getAddress(),
nonce: await Factory__L2ERC721Bridge.signer.getTransactionCount(),
})
)
await L1ERC721Bridge.deployed()
L2ERC721Bridge = await Factory__L2ERC721Bridge.deploy(
predeploys.L2CrossDomainMessenger,
L1ERC721Bridge.address
)
await L2ERC721Bridge.deployed()
OptimismMintableERC721Factory =
await Factory__OptimismMintableERC721Factory.deploy(
L2ERC721Bridge.address,
await getChainId(env.l1Wallet.provider)
)
await OptimismMintableERC721Factory.deployed()
expect(await L1ERC721Bridge.otherBridge()).to.equal(L2ERC721Bridge.address)
expect(await L2ERC721Bridge.otherBridge()).to.equal(L1ERC721Bridge.address)
expect(await OptimismMintableERC721Factory.BRIDGE()).to.equal(
L2ERC721Bridge.address
)
// Create a L2 Standard ERC721 with the Standard ERC721 Factory
const tx = await OptimismMintableERC721Factory.createOptimismMintableERC721(
L1ERC721.address,
'L2ERC721',
'L2'
)
const receipt = await tx.wait()
// Get the OptimismMintableERC721Created event
const erc721CreatedEvent = receipt.events[0]
expect(erc721CreatedEvent.event).to.be.eq('OptimismMintableERC721Created')
OptimismMintableERC721 = await ethers.getContractAt(
Artifact__OptimismMintableERC721.abi,
erc721CreatedEvent.args.localToken
)
// Mint an L1 ERC721 to Bob on L1
const tx2 = await L1ERC721.mint(bobAddress, TOKEN_ID)
await tx2.wait()
// Approve the L1 Bridge to operate the NFT
const tx3 = await L1ERC721.approve(L1ERC721Bridge.address, TOKEN_ID)
await tx3.wait()
})
it('bridgeERC721', async () => {
await env.messenger.waitForMessageReceipt(
await L1ERC721Bridge.bridgeERC721(
L1ERC721.address,
OptimismMintableERC721.address,
TOKEN_ID,
FINALIZATION_GAS,
NON_NULL_BYTES
)
)
// The L1 Bridge now owns the L1 NFT
expect(await L1ERC721.ownerOf(TOKEN_ID)).to.equal(L1ERC721Bridge.address)
// Bob owns the NFT on L2
expect(await OptimismMintableERC721.ownerOf(TOKEN_ID)).to.equal(bobAddress)
})
it('bridgeERC721To', async () => {
await env.messenger.waitForMessageReceipt(
await L1ERC721Bridge.bridgeERC721To(
L1ERC721.address,
OptimismMintableERC721.address,
aliceAddress,
TOKEN_ID,
FINALIZATION_GAS,
NON_NULL_BYTES
)
)
// The L1 Bridge now owns the L1 NFT
expect(await L1ERC721.ownerOf(TOKEN_ID)).to.equal(L1ERC721Bridge.address)
// Alice owns the NFT on L2
expect(await OptimismMintableERC721.ownerOf(TOKEN_ID)).to.equal(
aliceAddress
)
})
withdrawalTest('bridgeERC721', async () => {
// Deposit an NFT into L2 so that there's something to withdraw
await env.messenger.waitForMessageReceipt(
await L1ERC721Bridge.bridgeERC721(
L1ERC721.address,
OptimismMintableERC721.address,
TOKEN_ID,
FINALIZATION_GAS,
NON_NULL_BYTES
)
)
// First, check that the L1 Bridge now owns the L1 NFT
expect(await L1ERC721.ownerOf(TOKEN_ID)).to.equal(L1ERC721Bridge.address)
// Also check that Bob owns the NFT on L2 initially
expect(await OptimismMintableERC721.ownerOf(TOKEN_ID)).to.equal(bobAddress)
const tx = await L2ERC721Bridge.bridgeERC721(
OptimismMintableERC721.address,
L1ERC721.address,
TOKEN_ID,
0,
NON_NULL_BYTES
)
await tx.wait()
await env.relayXDomainMessages(tx)
// L1 NFT has been sent back to Bob
expect(await L1ERC721.ownerOf(TOKEN_ID)).to.equal(bobAddress)
// L2 NFT is burned
await expect(OptimismMintableERC721.ownerOf(TOKEN_ID)).to.be.reverted
})
withdrawalTest('bridgeERC721To', async () => {
// Deposit an NFT into L2 so that there's something to withdraw
await env.messenger.waitForMessageReceipt(
await L1ERC721Bridge.bridgeERC721(
L1ERC721.address,
OptimismMintableERC721.address,
TOKEN_ID,
FINALIZATION_GAS,
NON_NULL_BYTES
)
)
// First, check that the L1 Bridge now owns the L1 NFT
expect(await L1ERC721.ownerOf(TOKEN_ID)).to.equal(L1ERC721Bridge.address)
// Also check that Bob owns the NFT on L2 initially
expect(await OptimismMintableERC721.ownerOf(TOKEN_ID)).to.equal(bobAddress)
const tx = await L2ERC721Bridge.bridgeERC721To(
OptimismMintableERC721.address,
L1ERC721.address,
aliceAddress,
TOKEN_ID,
0,
NON_NULL_BYTES
)
await tx.wait()
await env.relayXDomainMessages(tx)
// L1 NFT has been sent to Alice
expect(await L1ERC721.ownerOf(TOKEN_ID)).to.equal(aliceAddress)
// L2 NFT is burned
await expect(OptimismMintableERC721.ownerOf(TOKEN_ID)).to.be.reverted
})
withdrawalTest(
'should not allow an arbitrary L2 NFT to be withdrawn in exchange for a legitimate L1 NFT',
async () => {
// First, deposit the legitimate L1 NFT.
await env.messenger.waitForMessageReceipt(
await L1ERC721Bridge.bridgeERC721(
L1ERC721.address,
OptimismMintableERC721.address,
TOKEN_ID,
FINALIZATION_GAS,
NON_NULL_BYTES
)
)
// Check that the L1 Bridge owns the L1 NFT initially
expect(await L1ERC721.ownerOf(TOKEN_ID)).to.equal(L1ERC721Bridge.address)
// Deploy a fake L2 ERC721, which:
// - Returns the address of the legitimate L1 token from its l1Token() getter.
// - Allows the L2 bridge to call its burn() function.
const FakeOptimismMintableERC721 = await (
await ethers.getContractFactory(
'FakeOptimismMintableERC721',
bobWalletL2
)
).deploy(
L2ERC721Bridge.address,
L1ERC721.address,
await getChainId(env.l1Wallet.provider)
)
await FakeOptimismMintableERC721.deployed()
// Use the fake contract to mint Alice an NFT with the same token ID
const tx = await FakeOptimismMintableERC721.safeMint(
aliceAddress,
TOKEN_ID
)
await tx.wait()
// Check that Alice owns the NFT from the fake ERC721 contract
expect(await FakeOptimismMintableERC721.ownerOf(TOKEN_ID)).to.equal(
aliceAddress
)
// Alice withdraws the NFT from the fake contract to L1, hoping to receive the legitimate L1 NFT.
const withdrawalTx = await L2ERC721Bridge.connect(
aliceWalletL2
).bridgeERC721(
FakeOptimismMintableERC721.address,
L1ERC721.address,
TOKEN_ID,
0,
NON_NULL_BYTES
)
await withdrawalTx.wait()
await env.relayXDomainMessages(withdrawalTx)
// The legitimate NFT on L1 is still held in the bridge.
expect(await L1ERC721.ownerOf(TOKEN_ID)).to.equal(L1ERC721Bridge.address)
}
)
})
integration-tests/test/ovmcontext.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { ethers } from 'hardhat'
import { expectApprox } from '@eth-optimism/core-utils'
import { predeploys } from '@eth-optimism/contracts'
import { Contract, BigNumber } from 'ethers'
/* Imports: Internal */
import { expect } from './shared/setup'
import { envConfig, DEFAULT_TEST_GAS_L1 } from './shared/utils'
import { OptimismEnv } from './shared/env'
/**
* These tests cover the OVM execution contexts. In the OVM execution
* of a L1 to L2 transaction, both `block.number` and `block.timestamp`
* must be equal to the blocknumber/timestamp of the L1 transaction.
*/
describe('OVM Context: Layer 2 EVM Context', () => {
let env: OptimismEnv
before(async () => {
env = await OptimismEnv.new()
})
let Multicall: Contract
let OVMContextStorage: Contract
beforeEach(async () => {
const OVMContextStorageFactory = await ethers.getContractFactory(
'OVMContextStorage',
env.l2Wallet
)
const MulticallFactory = await ethers.getContractFactory(
'Multicall',
env.l2Wallet
)
OVMContextStorage = await OVMContextStorageFactory.deploy()
await OVMContextStorage.deployTransaction.wait()
Multicall = await MulticallFactory.deploy()
await Multicall.deployTransaction.wait()
})
const numTxs = envConfig.OVMCONTEXT_SPEC_NUM_TXS
it('enqueue: L1 contextual values are correctly set in L2', async () => {
for (let i = 0; i < numTxs; i++) {
// Send a transaction from L1 to L2. This will automatically update the L1 contextual
// information like the L1 block number and L1 timestamp.
const tx =
await env.messenger.contracts.l1.L1CrossDomainMessenger.sendMessage(
OVMContextStorage.address,
'0x',
2_000_000,
{
gasLimit: DEFAULT_TEST_GAS_L1,
}
)
// Wait for the transaction to be sent over to L2.
await tx.wait()
const pair = await env.waitForXDomainTransaction(tx)
// Get the L1 block that the enqueue transaction was in so that
// the timestamp can be compared against the layer two contract
const l1Block = await env.l1Provider.getBlock(pair.receipt.blockNumber)
const l2Block = await env.l2Provider.getBlock(
pair.remoteReceipt.blockNumber
)
// block.number should return the value of the L2 block number.
const l2BlockNumber = await OVMContextStorage.blockNumbers(i)
expect(l2BlockNumber.toNumber()).to.deep.equal(l2Block.number)
// L1BLOCKNUMBER opcode should return the value of the L1 block number.
const l1BlockNumber = await OVMContextStorage.l1BlockNumbers(i)
expect(l1BlockNumber.toNumber()).to.deep.equal(l1Block.number)
// L1 and L2 blocks will have approximately the same timestamp.
const timestamp = await OVMContextStorage.timestamps(i)
expectApprox(timestamp.toNumber(), l1Block.timestamp, {
percentUpperDeviation: 5,
})
expect(timestamp.toNumber()).to.deep.equal(l2Block.timestamp)
// Difficulty should always be zero.
const difficulty = await OVMContextStorage.difficulty(i)
expect(difficulty.toNumber()).to.equal(0)
// Coinbase should always be sequencer fee vault.
const coinbase = await OVMContextStorage.coinbases(i)
expect(coinbase).to.equal(predeploys.OVM_SequencerFeeVault)
}
})
it('should set correct OVM Context for `eth_call`', async () => {
for (let i = 0; i < numTxs; i++) {
// Make an empty transaction to bump the latest block number.
const dummyTx = await env.l2Wallet.sendTransaction({
to: `0x${'11'.repeat(20)}`,
data: '0x',
})
await dummyTx.wait()
const block = await env.l2Provider.getBlockWithTransactions('latest')
const [, returnData] = await Multicall.callStatic.aggregate(
[
[
OVMContextStorage.address,
OVMContextStorage.interface.encodeFunctionData(
'getCurrentBlockTimestamp'
),
],
[
OVMContextStorage.address,
OVMContextStorage.interface.encodeFunctionData(
'getCurrentBlockNumber'
),
],
[
OVMContextStorage.address,
OVMContextStorage.interface.encodeFunctionData(
'getCurrentL1BlockNumber'
),
],
],
{ blockTag: block.number }
)
const timestamp = BigNumber.from(returnData[0])
const blockNumber = BigNumber.from(returnData[1])
const l1BlockNumber = BigNumber.from(returnData[2])
const tx = block.transactions[0] as any
expect(tx.l1BlockNumber).to.deep.equal(l1BlockNumber.toNumber())
expect(block.timestamp).to.deep.equal(timestamp.toNumber())
expect(block.number).to.deep.equal(blockNumber.toNumber())
}
})
/**
* `rollup_getInfo` is a new RPC endpoint that is used to return the OVM
* context. The data returned should match what is actually being used as the
* OVM context.
*/
// TODO: This test is not reliable. If we really care about this then we need to figure out a
// more reliable way to test this behavior.
it.skip('should return same timestamp and blocknumbers between `eth_call` and `rollup_getInfo`', async () => {
// // As atomically as possible, call `rollup_getInfo` and Multicall for the
// // blocknumber and timestamp. If this is not atomic, then the sequencer can
// // happend to update the timestamp between the `eth_call` and the `rollup_getInfo`
// const [info, [, returnData]] = await Promise.all([
// L2Provider.send('rollup_getInfo', []),
// Multicall.callStatic.aggregate([
// [
// OVMContextStorage.address,
// OVMContextStorage.interface.encodeFunctionData(
// 'getCurrentBlockTimestamp'
// ),
// ],
// [
// OVMContextStorage.address,
// OVMContextStorage.interface.encodeFunctionData(
// 'getCurrentL1BlockNumber'
// ),
// ],
// ]),
// ])
// const timestamp = BigNumber.from(returnData[0])
// const blockNumber = BigNumber.from(returnData[1])
// expect(info.ethContext.blockNumber).to.deep.equal(blockNumber.toNumber())
// expect(info.ethContext.timestamp).to.deep.equal(timestamp.toNumber())
})
})
integration-tests/test/predeploys.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { ethers } from 'ethers'
import { predeploys, getContractInterface } from '@eth-optimism/contracts'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
describe('predeploys', () => {
let env: OptimismEnv
before(async () => {
env = await OptimismEnv.new()
})
describe('WETH9', () => {
let weth9: ethers.Contract
before(() => {
weth9 = new ethers.Contract(
predeploys.WETH9,
getContractInterface('WETH9'),
env.l2Wallet
)
})
it('should have the correct name', async () => {
expect(await weth9.name()).to.equal('Wrapped Ether')
})
it('should have the correct symbol', async () => {
expect(await weth9.symbol()).to.equal('WETH')
})
it('should have the correct decimals', async () => {
expect(await weth9.decimals()).to.equal(18)
})
})
describe('OVM_ETH', () => {
let ovmEth: ethers.Contract
before(() => {
ovmEth = new ethers.Contract(
predeploys.OVM_ETH,
getContractInterface('OVM_ETH'),
env.l2Wallet
)
})
it('should have the correct name', async () => {
expect(await ovmEth.name()).to.equal('Ether')
})
it('should have the correct symbol', async () => {
expect(await ovmEth.symbol()).to.equal('ETH')
})
it('should have the correct decimals', async () => {
expect(await ovmEth.decimals()).to.equal(18)
})
})
describe('L2CrossDomainMessenger', () => {
let l2CrossDomainMessenger: ethers.Contract
before(() => {
l2CrossDomainMessenger = new ethers.Contract(
predeploys.L2CrossDomainMessenger,
getContractInterface('L2CrossDomainMessenger'),
env.l2Wallet
)
})
it('should throw when calling xDomainMessageSender', async () => {
await expect(
l2CrossDomainMessenger.xDomainMessageSender()
).to.be.revertedWith('xDomainMessageSender is not set')
})
})
describe('L2StandardBridge', () => {
let l2StandardBridge: ethers.Contract
before(() => {
l2StandardBridge = new ethers.Contract(
predeploys.L2StandardBridge,
getContractInterface('L2StandardBridge'),
env.l2Wallet
)
})
it('should have the correct messenger address', async () => {
expect(await l2StandardBridge.messenger()).to.equal(
predeploys.L2CrossDomainMessenger
)
})
it('should have a nonzero bridge address', async () => {
expect(await l2StandardBridge.l1TokenBridge()).to.not.equal(
ethers.constants.AddressZero
)
})
})
describe('OVM_SequencerFeeVault', () => {
let ovmSequencerFeeVault: ethers.Contract
before(() => {
ovmSequencerFeeVault = new ethers.Contract(
predeploys.OVM_SequencerFeeVault,
getContractInterface('OVM_SequencerFeeVault'),
env.l2Wallet
)
})
it('should have a nonzero l1FeeWallet', async () => {
expect(await ovmSequencerFeeVault.l1FeeWallet()).to.not.equal(
ethers.constants.AddressZero
)
})
})
})
integration-tests/test/queue-ingestion.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: Internal */
import { providers } from 'ethers'
import { applyL1ToL2Alias } from '@eth-optimism/core-utils'
import { asL2Provider } from '@eth-optimism/sdk'
import { getContractInterface } from '@eth-optimism/contracts'
/* Imports: External */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import { DEFAULT_TEST_GAS_L1, envConfig } from './shared/utils'
describe('Queue Ingestion', () => {
let env: OptimismEnv
let l2Provider: providers.JsonRpcProvider
before(async () => {
env = await OptimismEnv.new()
l2Provider = asL2Provider(env.l2Wallet.provider as any)
})
// The batch submitter will notice that there are transactions
// that are in the queue and submit them. L2 will pick up the
// sequencer batch appended event and play the transactions.
it('should order transactions correctly', async () => {
const numTxs = envConfig.OVMCONTEXT_SPEC_NUM_TXS
// Enqueue some transactions by building the calldata and then sending
// the transaction to Layer 1
const txs = []
for (let i = 0; i < numTxs; i++) {
const tx =
await env.messenger.contracts.l1.L1CrossDomainMessenger.sendMessage(
`0x${`${i}`.repeat(40)}`,
`0x0${i}`,
1_000_000,
{
gasLimit: DEFAULT_TEST_GAS_L1,
}
)
await tx.wait()
txs.push(tx)
}
for (let i = 0; i < numTxs; i++) {
const l1Tx = txs[i]
const l1TxReceipt = await txs[i].wait()
const receipt = await env.waitForXDomainTransaction(l1Tx)
const l2Tx = (await l2Provider.getTransaction(
receipt.remoteTx.hash
)) as any
const params = getContractInterface(
'L2CrossDomainMessenger'
).decodeFunctionData('relayMessage', l2Tx.data)
expect(params._sender.toLowerCase()).to.equal(
env.l1Wallet.address.toLowerCase()
)
expect(params._target).to.equal('0x' + `${i}`.repeat(40))
expect(l2Tx.queueOrigin).to.equal('l1')
expect(l2Tx.l1TxOrigin.toLowerCase()).to.equal(
applyL1ToL2Alias(
env.messenger.contracts.l1.L1CrossDomainMessenger.address
).toLowerCase()
)
expect(l2Tx.l1BlockNumber).to.equal(l1TxReceipt.blockNumber)
}
})
})
integration-tests/test/replica.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { TransactionReceipt } from '@ethersproject/abstract-provider'
import { sleep } from '@eth-optimism/core-utils'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import {
defaultTransactionFactory,
gasPriceForL2,
envConfig,
} from './shared/utils'
describe('Replica Tests', () => {
let env: OptimismEnv
before(async function () {
if (!envConfig.RUN_REPLICA_TESTS) {
this.skip()
return
}
env = await OptimismEnv.new()
})
describe('Matching blocks', () => {
it('should sync a transaction', async () => {
const tx = defaultTransactionFactory()
tx.gasPrice = await gasPriceForL2()
const result = await env.l2Wallet.sendTransaction(tx)
let receipt: TransactionReceipt
while (!receipt) {
receipt = await env.replicaProvider.getTransactionReceipt(result.hash)
await sleep(200)
}
const sequencerBlock = (await env.l2Provider.getBlock(
result.blockNumber
)) as any
const replicaBlock = (await env.replicaProvider.getBlock(
result.blockNumber
)) as any
expect(sequencerBlock.stateRoot).to.deep.eq(replicaBlock.stateRoot)
expect(sequencerBlock.hash).to.deep.eq(replicaBlock.hash)
})
it('sync an unprotected tx (eip155)', async () => {
const tx = {
...defaultTransactionFactory(),
nonce: await env.l2Wallet.getTransactionCount(),
gasPrice: await gasPriceForL2(),
chainId: null, // Disables EIP155 transaction signing.
}
const signed = await env.l2Wallet.signTransaction(tx)
const result = await env.l2Provider.sendTransaction(signed)
let receipt: TransactionReceipt
while (!receipt) {
receipt = await env.replicaProvider.getTransactionReceipt(result.hash)
await sleep(200)
}
const sequencerBlock = (await env.l2Provider.getBlock(
result.blockNumber
)) as any
const replicaBlock = (await env.replicaProvider.getBlock(
result.blockNumber
)) as any
expect(sequencerBlock.stateRoot).to.deep.eq(replicaBlock.stateRoot)
expect(sequencerBlock.hash).to.deep.eq(replicaBlock.hash)
})
it('should forward tx to sequencer', async () => {
const tx = {
...defaultTransactionFactory(),
nonce: await env.l2Wallet.getTransactionCount(),
gasPrice: await gasPriceForL2(),
}
const signed = await env.l2Wallet.signTransaction(tx)
const result = await env.replicaProvider.sendTransaction(signed)
let receipt: TransactionReceipt
while (!receipt) {
receipt = await env.replicaProvider.getTransactionReceipt(result.hash)
await sleep(200)
}
const sequencerBlock = (await env.l2Provider.getBlock(
result.blockNumber
)) as any
const replicaBlock = (await env.replicaProvider.getBlock(
result.blockNumber
)) as any
expect(sequencerBlock.stateRoot).to.deep.eq(replicaBlock.stateRoot)
expect(sequencerBlock.hash).to.deep.eq(replicaBlock.hash)
})
})
})
integration-tests/test/rpc.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { expectApprox, getChainId, sleep } from '@eth-optimism/core-utils'
import { Wallet, BigNumber, Contract, ContractFactory, constants } from 'ethers'
import { serialize } from '@ethersproject/transactions'
import { ethers } from 'hardhat'
import {
TransactionReceipt,
TransactionRequest,
} from '@ethersproject/providers'
/* Imports: Internal */
import { expect } from './shared/setup'
import {
defaultTransactionFactory,
fundUser,
L2_CHAINID,
gasPriceForL2,
isHardhat,
hardhatTest,
envConfig,
gasPriceOracleWallet,
} from './shared/utils'
import { OptimismEnv } from './shared/env'
describe('Basic RPC tests', () => {
let env: OptimismEnv
let wallet: Wallet
let Reverter: Contract
let ValueContext: Contract
let revertMessage: string
let revertingTx: TransactionRequest
let revertingDeployTx: TransactionRequest
before(async () => {
env = await OptimismEnv.new()
wallet = env.l2Wallet
const Factory__Reverter = await ethers.getContractFactory(
'Reverter',
wallet
)
Reverter = await Factory__Reverter.connect(env.l2Wallet).deploy()
await Reverter.deployTransaction.wait()
revertMessage = await Reverter.revertMessage()
revertingTx = {
to: Reverter.address,
data: Reverter.interface.encodeFunctionData('doRevert'),
}
const Factory__ConstructorReverter = await ethers.getContractFactory(
'ConstructorReverter',
wallet
)
revertingDeployTx = {
data: Factory__ConstructorReverter.bytecode,
}
// Deploy a contract to check msg.value of the call
const Factory__ValueContext: ContractFactory =
await ethers.getContractFactory('ValueContext', wallet)
ValueContext = await Factory__ValueContext.deploy()
await ValueContext.deployTransaction.wait()
})
describe('eth_sendRawTransaction', () => {
it('should correctly process a valid transaction', async () => {
const tx = defaultTransactionFactory()
tx.gasPrice = await gasPriceForL2()
const nonce = await wallet.getTransactionCount()
const result = await wallet.sendTransaction(tx)
expect(result.from).to.equal(wallet.address)
expect(result.nonce).to.equal(nonce)
expect(result.gasLimit.toNumber()).to.equal(tx.gasLimit)
expect(result.gasPrice.toNumber()).to.equal(tx.gasPrice)
expect(result.data).to.equal(tx.data)
})
it('should not accept a transaction with the wrong chain ID', async () => {
const tx = {
...defaultTransactionFactory(),
gasPrice: await gasPriceForL2(),
chainId: (await wallet.getChainId()) + 1,
}
await expect(
env.l2Provider.sendTransaction(await wallet.signTransaction(tx))
).to.be.rejectedWith('invalid transaction: invalid sender')
})
it('should accept a transaction without a chain ID', async () => {
const tx = {
...defaultTransactionFactory(),
nonce: await wallet.getTransactionCount(),
gasPrice: await gasPriceForL2(),
chainId: null, // Disables EIP155 transaction signing.
}
const signed = await wallet.signTransaction(tx)
const response = await env.l2Provider.sendTransaction(signed)
expect(response.chainId).to.equal(0)
const v = response.v
expect(v === 27 || v === 28).to.be.true
})
it('should accept a transaction with a value', async () => {
const tx = {
...defaultTransactionFactory(),
gasPrice: await gasPriceForL2(),
chainId: await env.l2Wallet.getChainId(),
data: '0x',
value: ethers.utils.parseEther('0.1'),
}
const balanceBefore = await env.l2Provider.getBalance(
env.l2Wallet.address
)
const result = await env.l2Wallet.sendTransaction(tx)
const receipt = await result.wait()
expect(receipt.status).to.deep.equal(1)
const balAfter = await env.l2Provider.getBalance(env.l2Wallet.address)
expect(balAfter.lte(balanceBefore.sub(ethers.utils.parseEther('0.1')))).to
.be.true
})
it('should reject a transaction with higher value than user balance', async () => {
const balance = await env.l2Wallet.getBalance()
const tx = {
...defaultTransactionFactory(),
gasPrice: await gasPriceForL2(),
chainId: await env.l2Wallet.getChainId(),
data: '0x',
value: balance.add(ethers.utils.parseEther('1')),
}
await expect(env.l2Wallet.sendTransaction(tx)).to.be.rejectedWith(
'invalid transaction: insufficient funds for gas * price + value'
)
})
it('should correctly report OOG for contract creations', async () => {
const factory = await ethers.getContractFactory('TestOOGInConstructor')
await expect(factory.connect(wallet).deploy()).to.be.rejectedWith(
'gas required exceeds allowance'
)
})
it('should reject a transaction with too low of a fee', async () => {
const isHH = await isHardhat()
let gasPrice
if (isHH) {
gasPrice = await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).gasPrice()
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).setGasPrice(1000)
}
const tx = {
...defaultTransactionFactory(),
gasPrice: 1,
}
await expect(env.l2Wallet.sendTransaction(tx)).to.be.rejectedWith(
/gas price too low: 1 wei, use at least tx\.gasPrice = \d+ wei/
)
if (isHH) {
// Reset the gas price to its original price
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).setGasPrice(gasPrice)
}
})
it('should reject a transaction with too high of a fee', async () => {
const gasPrice =
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).gasPrice()
const largeGasPrice = gasPrice.mul(10)
const tx = {
...defaultTransactionFactory(),
gasPrice: largeGasPrice,
}
await expect(env.l2Wallet.sendTransaction(tx)).to.be.rejectedWith(
`gas price too high: ${largeGasPrice.toString()} wei, use at most ` +
`tx.gasPrice = ${gasPrice.toString()} wei`
)
})
})
describe('eth_call', () => {
it('should correctly identify call out-of-gas', async () => {
await expect(
env.l2Provider.call({
...revertingTx,
gasLimit: 1,
})
).to.be.rejectedWith('out of gas')
})
it('should correctly return solidity revert data from a call', async () => {
await expect(env.l2Provider.call(revertingTx)).to.be.revertedWith(
revertMessage
)
})
it('should produce error when called from ethers', async () => {
await expect(Reverter.doRevert()).to.be.revertedWith(revertMessage)
})
it('should correctly return revert data from contract creation', async () => {
await expect(env.l2Provider.call(revertingDeployTx)).to.be.revertedWith(
revertMessage
)
})
it('should correctly identify contract creation out of gas', async () => {
await expect(
env.l2Provider.call({
...revertingDeployTx,
gasLimit: 1,
})
).to.be.rejectedWith('out of gas')
})
it('should allow eth_calls with nonzero value', async () => {
// Fund account to call from
const from = wallet.address
const value = 15
await fundUser(env.messenger, value, from)
// Do the call and check msg.value
const data = ValueContext.interface.encodeFunctionData('getCallValue')
const res = await env.l2Provider.call({
to: ValueContext.address,
from,
data,
value,
})
expect(res).to.eq(BigNumber.from(value))
})
// https://github.com/ethereum-optimism/optimism/issues/1998
it('should use address(0) as the default "from" value', async () => {
// Do the call and check msg.sender
const data = ValueContext.interface.encodeFunctionData('getCaller')
const res = await env.l2Provider.call({
to: ValueContext.address,
data,
})
const [paddedRes] = ValueContext.interface.decodeFunctionResult(
'getCaller',
res
)
expect(paddedRes).to.eq(constants.AddressZero)
})
it('should correctly use the "from" value', async () => {
const from = wallet.address
// Do the call and check msg.sender
const data = ValueContext.interface.encodeFunctionData('getCaller')
const res = await env.l2Provider.call({
to: ValueContext.address,
from,
data,
})
const [paddedRes] = ValueContext.interface.decodeFunctionResult(
'getCaller',
res
)
expect(paddedRes).to.eq(from)
})
it('should be deterministic', async () => {
let res = await ValueContext.callStatic.getSelfBalance()
for (let i = 0; i < 10; i++) {
const next = await ValueContext.callStatic.getSelfBalance()
expect(res.toNumber()).to.deep.eq(next.toNumber())
res = next
}
})
})
describe('eth_getTransactionReceipt', () => {
it('correctly exposes revert data for contract calls', async () => {
const req: TransactionRequest = {
...revertingTx,
gasLimit: 8_000_000, // override gas estimation
}
const tx = await wallet.sendTransaction(req)
let errored = false
try {
await tx.wait()
} catch (e) {
errored = true
}
expect(errored).to.be.true
const receipt: TransactionReceipt =
await env.l2Provider.getTransactionReceipt(tx.hash)
expect(receipt.status).to.eq(0)
})
it('correctly exposes revert data for contract creations', async () => {
const req: TransactionRequest = {
...revertingDeployTx,
gasLimit: 8_000_000, // override gas estimation
}
const tx = await wallet.sendTransaction(req)
let errored = false
try {
await tx.wait()
} catch (e) {
errored = true
}
expect(errored).to.be.true
const receipt: TransactionReceipt =
await env.l2Provider.getTransactionReceipt(tx.hash)
expect(receipt.status).to.eq(0)
})
// Optimism special fields on the receipt
it('includes L1 gas price and L1 gas used', async () => {
const tx = await env.l2Wallet.populateTransaction({
to: env.l2Wallet.address,
gasPrice: await gasPriceForL2(),
})
const raw = serialize({
nonce: parseInt(tx.nonce.toString(), 10),
to: tx.to,
gasLimit: tx.gasLimit,
gasPrice: tx.gasPrice,
type: tx.type,
data: tx.data,
})
const l1Fee = await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).getL1Fee(raw)
const l1GasPrice =
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).l1BaseFee()
const l1GasUsed =
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).getL1GasUsed(raw)
const scalar =
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).scalar()
const decimals =
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).decimals()
const scaled = scalar.toNumber() / 10 ** decimals.toNumber()
const res = await env.l2Wallet.sendTransaction(tx)
await res.wait()
const json = await env.l2Provider.send('eth_getTransactionReceipt', [
res.hash,
])
expect(l1GasUsed).to.deep.equal(BigNumber.from(json.l1GasUsed))
expect(l1GasPrice).to.deep.equal(BigNumber.from(json.l1GasPrice))
expect(scaled.toString()).to.deep.equal(json.l1FeeScalar)
expect(l1Fee).to.deep.equal(BigNumber.from(json.l1Fee))
})
})
describe('eth_getTransactionByHash', () => {
it('should be able to get all relevant l1/l2 transaction data', async () => {
const tx = defaultTransactionFactory()
tx.gasPrice = await gasPriceForL2()
const result = await wallet.sendTransaction(tx)
await result.wait()
const transaction = (await env.l2Provider.getTransaction(
result.hash
)) as any
expect(transaction.queueOrigin).to.equal('sequencer')
expect(transaction.transactionIndex).to.be.eq(0)
expect(transaction.gasLimit).to.be.deep.eq(BigNumber.from(tx.gasLimit))
})
})
describe('eth_getBlockByHash', () => {
it('should return the block and all included transactions', async () => {
// Send a transaction and wait for it to be mined.
const tx = defaultTransactionFactory()
tx.gasPrice = await gasPriceForL2()
const result = await wallet.sendTransaction(tx)
const receipt = await result.wait()
const block = (await env.l2Provider.getBlockWithTransactions(
receipt.blockHash
)) as any
expect(block.number).to.not.equal(0)
expect(typeof block.stateRoot).to.equal('string')
expect(block.transactions.length).to.equal(1)
expect(block.transactions[0].queueOrigin).to.equal('sequencer')
expect(block.transactions[0].l1TxOrigin).to.equal(null)
})
})
describe('eth_getBlockByNumber', () => {
// There was a bug that causes transactions to be reingested over
// and over again only when a single transaction was in the
// canonical transaction chain. This test catches this by
// querying for the latest block and then waits and then queries
// the latest block again and then asserts that they are the same.
//
// Needs to be skipped on Prod networks because this test doesn't work when
// other people are sending transactions to the Sequencer at the same time
// as this test is running.
hardhatTest(
'should return the same result when new transactions are not applied',
async () => {
// Get latest block once to start.
const prev = await env.l2Provider.getBlockWithTransactions('latest')
// set wait to null to allow a deep object comparison
prev.transactions[0].wait = null
// Over ten seconds, repeatedly check the latest block to make sure nothing has changed.
for (let i = 0; i < 5; i++) {
const latest = await env.l2Provider.getBlockWithTransactions('latest')
latest.transactions[0].wait = null
// Check each key of the transaction individually
// for easy debugging if one field changes
for (const [key, value] of Object.entries(latest.transactions[0])) {
expect(value).to.deep.equal(
prev.transactions[0][key],
`mismatch ${key}`
)
}
expect(latest).to.deep.equal(prev)
await sleep(2000)
}
}
)
})
describe('eth_getBalance', () => {
it('should get the OVM_ETH balance', async () => {
const rpcBalance = await env.l2Provider.getBalance(env.l2Wallet.address)
const contractBalance =
await env.messenger.contracts.l2.OVM_ETH.balanceOf(env.l2Wallet.address)
expect(rpcBalance).to.be.deep.eq(contractBalance)
})
})
describe('eth_chainId', () => {
it('should get the correct chainid', async () => {
expect(await getChainId(env.l2Provider)).to.be.eq(L2_CHAINID)
})
})
describe('eth_estimateGas', () => {
it('simple send gas estimation is deterministic', async () => {
let lastEstimate: BigNumber
for (let i = 0; i < 10; i++) {
const estimate = await env.l2Provider.estimateGas({
to: defaultTransactionFactory().to,
value: 0,
})
if (i > 0) {
expect(lastEstimate).to.be.eq(estimate)
}
lastEstimate = estimate
}
})
it('deterministic gas estimation for evm execution', async () => {
let res = await ValueContext.estimateGas.getSelfBalance()
for (let i = 0; i < 10; i++) {
const next = await ValueContext.estimateGas.getSelfBalance()
expect(res.toNumber()).to.deep.eq(next.toNumber())
res = next
}
})
it('should return a gas estimate for txs with empty data', async () => {
const estimate = await env.l2Provider.estimateGas({
to: defaultTransactionFactory().to,
value: 0,
})
// Expect gas to be less than or equal to the target plus 1%
expectApprox(estimate, 21000, { percentUpperDeviation: 1 })
})
it('should fail for a reverting call transaction', async () => {
await expect(env.l2Provider.send('eth_estimateGas', [revertingTx])).to.be
.reverted
})
it('should fail for a reverting deploy transaction', async () => {
await expect(env.l2Provider.send('eth_estimateGas', [revertingDeployTx]))
.to.be.reverted
})
})
describe('debug_traceTransaction', () => {
before(async function () {
if (!envConfig.RUN_DEBUG_TRACE_TESTS) {
this.skip()
}
})
it('should match debug_traceBlock', async () => {
const storage = await ethers.getContractFactory(
'SimpleStorage',
env.l2Wallet
)
const tx = (await storage.deploy()).deployTransaction
const receipt = await tx.wait()
const txTrace = await env.l2Provider.send('debug_traceTransaction', [
receipt.transactionHash,
])
const blockTrace = await env.l2Provider.send('debug_traceBlockByHash', [
receipt.blockHash,
])
expect(txTrace).to.deep.equal(blockTrace[0].result)
})
})
describe('rollup_gasPrices', () => {
it('should return the L1 and L2 gas prices', async () => {
const result = await env.l2Provider.send('rollup_gasPrices', [])
const l1GasPrice =
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).l1BaseFee()
const l2GasPrice =
await env.messenger.contracts.l2.OVM_GasPriceOracle.connect(
gasPriceOracleWallet
).gasPrice()
expect(BigNumber.from(result.l1GasPrice)).to.deep.eq(l1GasPrice)
expect(BigNumber.from(result.l2GasPrice)).to.deep.eq(l2GasPrice)
})
})
})
integration-tests/test/shared/env.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { utils, Wallet, providers, Transaction } from 'ethers'
import {
TransactionResponse,
TransactionReceipt,
} from '@ethersproject/providers'
import { getChainId, sleep } from '@eth-optimism/core-utils'
import {
CrossChainMessenger,
MessageStatus,
MessageDirection,
StandardBridgeAdapter,
ETHBridgeAdapter,
BridgeAdapterData,
} from '@eth-optimism/sdk'
import { predeploys } from '@eth-optimism/contracts'
/* Imports: Internal */
import {
l1Provider,
l2Provider,
replicaProvider,
verifierProvider,
l1Wallet,
l2Wallet,
fundUser,
envConfig,
} from './utils'
export interface CrossDomainMessagePair {
tx: Transaction
receipt: TransactionReceipt
remoteTx: Transaction
remoteReceipt: TransactionReceipt
}
/// Helper class for instantiating a test environment with a funded account
export class OptimismEnv {
// The wallets
l1Wallet: Wallet
l2Wallet: Wallet
// The providers
messenger: CrossChainMessenger
l1Provider: providers.JsonRpcProvider
l2Provider: providers.JsonRpcProvider
replicaProvider: providers.JsonRpcProvider
verifierProvider: providers.JsonRpcProvider
constructor(args: any) {
this.l1Wallet = args.l1Wallet
this.l2Wallet = args.l2Wallet
this.messenger = args.messenger
this.l1Provider = args.l1Provider
this.l2Provider = args.l2Provider
this.replicaProvider = args.replicaProvider
this.verifierProvider = args.verifierProvider
}
static async new(): Promise<OptimismEnv> {
let bridgeOverrides: BridgeAdapterData
if (envConfig.L1_STANDARD_BRIDGE) {
bridgeOverrides = {
Standard: {
Adapter: StandardBridgeAdapter,
l1Bridge: envConfig.L1_STANDARD_BRIDGE,
l2Bridge: predeploys.L2StandardBridge,
},
ETH: {
Adapter: ETHBridgeAdapter,
l1Bridge: envConfig.L1_STANDARD_BRIDGE,
l2Bridge: predeploys.L2StandardBridge,
},
}
}
const messenger = new CrossChainMessenger({
l1SignerOrProvider: l1Wallet,
l2SignerOrProvider: l2Wallet,
l1ChainId: await getChainId(l1Provider),
l2ChainId: await getChainId(l2Provider),
contracts: {
l1: {
AddressManager: envConfig.ADDRESS_MANAGER,
L1CrossDomainMessenger: envConfig.L1_CROSS_DOMAIN_MESSENGER,
L1StandardBridge: envConfig.L1_STANDARD_BRIDGE,
StateCommitmentChain: envConfig.STATE_COMMITMENT_CHAIN,
CanonicalTransactionChain: envConfig.CANONICAL_TRANSACTION_CHAIN,
BondManager: envConfig.BOND_MANAGER,
},
},
bridges: bridgeOverrides,
})
// fund the user if needed
const balance = await l2Wallet.getBalance()
const min = envConfig.L2_WALLET_MIN_BALANCE_ETH.toString()
const topUp = envConfig.L2_WALLET_TOP_UP_AMOUNT_ETH.toString()
if (balance.lt(utils.parseEther(min))) {
await fundUser(messenger, utils.parseEther(topUp))
}
return new OptimismEnv({
l1Wallet,
l2Wallet,
messenger,
l1Provider,
l2Provider,
verifierProvider,
replicaProvider,
})
}
async waitForXDomainTransaction(
tx: Promise<TransactionResponse> | TransactionResponse
): Promise<CrossDomainMessagePair> {
// await it if needed
tx = await tx
const receipt = await tx.wait()
const resolved = await this.messenger.toCrossChainMessage(tx)
const messageReceipt = await this.messenger.waitForMessageReceipt(tx)
let fullTx: any
let remoteTx: any
if (resolved.direction === MessageDirection.L1_TO_L2) {
fullTx = await this.messenger.l1Provider.getTransaction(tx.hash)
remoteTx = await this.messenger.l2Provider.getTransaction(
messageReceipt.transactionReceipt.transactionHash
)
} else {
fullTx = await this.messenger.l2Provider.getTransaction(tx.hash)
remoteTx = await this.messenger.l1Provider.getTransaction(
messageReceipt.transactionReceipt.transactionHash
)
}
return {
tx: fullTx,
receipt,
remoteTx,
remoteReceipt: messageReceipt.transactionReceipt,
}
}
/**
* Relays all L2 => L1 messages found in a given L2 transaction.
*
* @param tx Transaction to find messages in.
*/
async relayXDomainMessages(
tx: Promise<TransactionResponse> | TransactionResponse
): Promise<void> {
tx = await tx
await tx.wait()
const messages = await this.messenger.getMessagesByTransaction(tx)
if (messages.length === 0) {
return
}
for (const message of messages) {
await this.messenger.waitForMessageStatus(
message,
MessageStatus.READY_FOR_RELAY
)
let relayed = false
while (!relayed) {
try {
await this.messenger.finalizeMessage(message)
relayed = true
} catch (err) {
if (
err.message.includes('Nonce too low') ||
err.message.includes('transaction was replaced') ||
err.message.includes(
'another transaction with same nonce in the queue'
)
) {
// Sometimes happens when we run tests in parallel.
await sleep(5000)
} else if (
err.message.includes('message has already been received')
) {
// Message already relayed, this is fine.
relayed = true
} else {
throw err
}
}
}
await this.messenger.waitForMessageReceipt(message)
}
}
}
integration-tests/test/shared/setup.ts deleted 100644 → 0
View file @ cccce791
/* External Imports */
import chai = require('chai')
import chaiAsPromised from 'chai-as-promised'
import { solidity } from 'ethereum-waffle'
chai.use(solidity)
chai.use(chaiAsPromised)
const expect = chai.expect
export { expect }
integration-tests/test/shared/stress-test-helpers.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { ethers } from 'ethers'
import { sleep } from '@eth-optimism/core-utils'
/* Imports: Internal */
import { OptimismEnv } from './env'
import { gasPriceForL1, gasPriceForL2 } from './utils'
interface TransactionParams {
contract: ethers.Contract
functionName: string
functionParams: any[]
}
// Arbitrary big amount of gas for the L1<>L2 messages.
const MESSAGE_GAS = 8_000_000
export const fundRandomWallet = async (
env: OptimismEnv,
wallet: ethers.Wallet,
value: ethers.BigNumber
): Promise<ethers.Wallet> => {
const fundTx = await env.l1Wallet.sendTransaction({
gasLimit: 25_000,
to: wallet.address,
gasPrice: await gasPriceForL1(),
value,
})
await fundTx.wait()
return wallet
}
export const executeL1ToL2Transaction = async (
env: OptimismEnv,
wallet: ethers.Wallet,
tx: TransactionParams
) => {
const signer = wallet.connect(env.l1Wallet.provider)
const receipt = await retryOnNonceError(async () =>
env.messenger.contracts.l1.L1CrossDomainMessenger.connect(
signer
).sendMessage(
tx.contract.address,
tx.contract.interface.encodeFunctionData(
tx.functionName,
tx.functionParams
),
MESSAGE_GAS,
{
gasPrice: await gasPriceForL1(),
}
)
)
await env.waitForXDomainTransaction(receipt)
}
export const executeL2ToL1Transaction = async (
env: OptimismEnv,
wallet: ethers.Wallet,
tx: TransactionParams
) => {
const signer = wallet.connect(env.l2Wallet.provider)
const receipt = await retryOnNonceError(() =>
env.messenger.contracts.l2.L2CrossDomainMessenger.connect(
signer
).sendMessage(
tx.contract.address,
tx.contract.interface.encodeFunctionData(
tx.functionName,
tx.functionParams
),
MESSAGE_GAS,
{
gasPrice: gasPriceForL2(),
}
)
)
await env.relayXDomainMessages(receipt)
await env.waitForXDomainTransaction(receipt)
}
export const executeL2Transaction = async (
env: OptimismEnv,
wallet: ethers.Wallet,
tx: TransactionParams
) => {
const signer = wallet.connect(env.l2Wallet.provider)
const result = await retryOnNonceError(() =>
tx.contract
.connect(signer)
.functions[tx.functionName](...tx.functionParams, {
gasPrice: gasPriceForL2(),
})
)
await result.wait()
}
export const executeRepeatedL1ToL2Transactions = async (
env: OptimismEnv,
wallets: ethers.Wallet[],
tx: TransactionParams
) => {
for (const wallet of wallets) {
await executeL1ToL2Transaction(env, wallet, tx)
}
}
export const executeRepeatedL2ToL1Transactions = async (
env: OptimismEnv,
wallets: ethers.Wallet[],
tx: TransactionParams
) => {
for (const wallet of wallets) {
await executeL2ToL1Transaction(env, wallet, tx)
}
}
export const executeRepeatedL2Transactions = async (
env: OptimismEnv,
wallets: ethers.Wallet[],
tx: TransactionParams
) => {
for (const wallet of wallets) {
await executeL2Transaction(env, wallet, tx)
}
}
export const executeL1ToL2TransactionsParallel = async (
env: OptimismEnv,
wallets: ethers.Wallet[],
tx: TransactionParams
) => {
await Promise.all(wallets.map((w) => executeL1ToL2Transaction(env, w, tx)))
}
export const executeL2ToL1TransactionsParallel = async (
env: OptimismEnv,
wallets: ethers.Wallet[],
tx: TransactionParams
) => {
await Promise.all(wallets.map((w) => executeL2ToL1Transaction(env, w, tx)))
}
export const executeL2TransactionsParallel = async (
env: OptimismEnv,
wallets: ethers.Wallet[],
tx: TransactionParams
) => {
await Promise.all(wallets.map((w) => executeL2Transaction(env, w, tx)))
}
const retryOnNonceError = async (cb: () => Promise<any>): Promise<any> => {
while (true) {
try {
return await cb()
} catch (err) {
const msg = err.message.toLowerCase()
if (
msg.includes('nonce too low') ||
msg.includes('nonce has already been used') ||
msg.includes('transaction was replaced') ||
msg.includes('another transaction with same nonce in the queue') ||
msg.includes('reverted without a reason')
) {
console.warn('Retrying transaction after nonce error.')
await sleep(5000)
continue
}
throw err
}
}
}
integration-tests/test/shared/utils.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { Wallet, providers, BigNumber, utils } from 'ethers'
import { predeploys } from '@eth-optimism/contracts'
import { remove0x } from '@eth-optimism/core-utils'
import {
CrossChainMessenger,
NumberLike,
asL2Provider,
} from '@eth-optimism/sdk'
import { cleanEnv, str, num, bool, makeValidator } from 'envalid'
import dotenv from 'dotenv'
dotenv.config()
/* Imports: Internal */
import { OptimismEnv } from './env'
export const isLiveNetwork = () => {
return process.env.IS_LIVE_NETWORK === 'true'
}
export const HARDHAT_CHAIN_ID = 31337
export const DEFAULT_TEST_GAS_L1 = 330_000
export const DEFAULT_TEST_GAS_L2 = 1_300_000
export const ON_CHAIN_GAS_PRICE = 'onchain'
const gasPriceValidator = makeValidator((gasPrice) => {
if (gasPrice === 'onchain') {
return gasPrice
}
return num()._parse(gasPrice).toString()
})
const addressValidator = makeValidator((addr) => {
if (!addr) {
return ''
} else if (utils.isAddress(addr)) {
return addr
} else {
throw new Error('Expected an address')
}
})
const procEnv = cleanEnv(process.env, {
L1_GAS_PRICE: gasPriceValidator({
default: '0',
}),
L1_URL: str({ default: 'http://localhost:9545' }),
L1_POLLING_INTERVAL: num({ default: 10 }),
L2_CHAINID: num({ default: 17 }),
L2_GAS_PRICE: gasPriceValidator({
default: 'onchain',
}),
L2_URL: str({ default: 'http://localhost:8545' }),
L2_POLLING_INTERVAL: num({ default: 10 }),
L2_WALLET_MIN_BALANCE_ETH: num({
default: 2,
}),
L2_WALLET_TOP_UP_AMOUNT_ETH: num({
default: 3,
}),
REPLICA_URL: str({ default: 'http://localhost:8549' }),
REPLICA_POLLING_INTERVAL: num({ default: 10 }),
VERIFIER_URL: str({ default: 'http://localhost:8547' }),
HEALTHCHECK_URL: str({ default: 'http://localhost:7300/metrics' }),
PRIVATE_KEY: str({
default:
'0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
}),
GAS_PRICE_ORACLE_PRIVATE_KEY: str({
default:
'0x8b3a350cf5c34c9194ca85829a2df0ec3153be0318b5e2d3348e872092edffba',
}),
OVMCONTEXT_SPEC_NUM_TXS: num({
default: 5,
}),
DTL_ENQUEUE_CONFIRMATIONS: num({
default: 0,
}),
RUN_WITHDRAWAL_TESTS: bool({
default: true,
}),
RUN_REPLICA_TESTS: bool({
default: true,
}),
RUN_HEALTHCHECK_TESTS: bool({
default: true,
}),
RUN_DEBUG_TRACE_TESTS: bool({
default: true,
}),
RUN_STRESS_TESTS: bool({
default: true,
}),
RUN_VERIFIER_TESTS: bool({
default: true,
}),
RUN_SYSTEM_ADDRESS_TESTS: bool({
default: false,
}),
MOCHA_TIMEOUT: num({
default: 120_000,
}),
MOCHA_BAIL: bool({
default: false,
}),
BATCH_SUBMITTER_SEQUENCER_BATCH_TYPE: str({
default: 'zlib',
}),
ADDRESS_MANAGER: addressValidator({
default: '',
}),
L1_CROSS_DOMAIN_MESSENGER: addressValidator({
default: '',
}),
L1_STANDARD_BRIDGE: addressValidator({
default: '',
}),
STATE_COMMITMENT_CHAIN: addressValidator({
default: '',
}),
CANONICAL_TRANSACTION_CHAIN: addressValidator({
default: '',
}),
BOND_MANAGER: addressValidator({
default: '',
}),
})
export const envConfig = procEnv
// The hardhat instance
export const l1Provider = new providers.JsonRpcProvider(procEnv.L1_URL)
l1Provider.pollingInterval = procEnv.L1_POLLING_INTERVAL
export const l2Provider = asL2Provider(
new providers.JsonRpcProvider(procEnv.L2_URL)
)
l2Provider.pollingInterval = procEnv.L2_POLLING_INTERVAL
export const replicaProvider = asL2Provider(
new providers.JsonRpcProvider(procEnv.REPLICA_URL)
)
replicaProvider.pollingInterval = procEnv.REPLICA_POLLING_INTERVAL
export const verifierProvider = asL2Provider(
new providers.JsonRpcProvider(procEnv.VERIFIER_URL)
)
verifierProvider.pollingInterval = procEnv.L2_POLLING_INTERVAL
// The sequencer private key which is funded on L1
export const l1Wallet = new Wallet(procEnv.PRIVATE_KEY, l1Provider)
// A random private key which should always be funded with deposits from L1 -> L2
// if it's using non-0 gas price
export const l2Wallet = l1Wallet.connect(l2Provider)
// The owner of the GasPriceOracle on L2
export const gasPriceOracleWallet = new Wallet(
procEnv.GAS_PRICE_ORACLE_PRIVATE_KEY,
l2Provider
)
// Predeploys
export const OVM_ETH_ADDRESS = predeploys.OVM_ETH
export const L2_CHAINID = procEnv.L2_CHAINID
export const fundUser = async (
messenger: CrossChainMessenger,
amount: NumberLike,
recipient?: string
) => {
await messenger.waitForMessageReceipt(
await messenger.depositETH(amount, {
l2GasLimit: DEFAULT_TEST_GAS_L2,
overrides: {
gasPrice: DEFAULT_TEST_GAS_L1,
},
})
)
if (recipient !== undefined) {
const tx = await messenger.l2Signer.sendTransaction({
to: recipient,
value: amount,
})
await tx.wait()
}
}
export const conditionalTest = (
condition: (env?: OptimismEnv) => Promise<boolean>,
name,
fn,
message?: string,
timeout?: number
) => {
it(name, async function () {
const shouldRun = await condition()
if (!shouldRun) {
console.log(message)
this.skip()
return
}
await fn()
}).timeout(timeout || envConfig.MOCHA_TIMEOUT * 2)
}
export const withdrawalTest = (name, fn, timeout?: number) =>
conditionalTest(
() => Promise.resolve(procEnv.RUN_WITHDRAWAL_TESTS),
name,
fn,
`Skipping withdrawal test.`,
timeout
)
export const hardhatTest = (name, fn) =>
conditionalTest(
isHardhat,
name,
fn,
'Skipping test on non-Hardhat environment.'
)
const abiCoder = new utils.AbiCoder()
export const encodeSolidityRevertMessage = (_reason: string): string => {
return '0x08c379a0' + remove0x(abiCoder.encode(['string'], [_reason]))
}
export const defaultTransactionFactory = () => {
return {
to: '0x' + '1234'.repeat(10),
gasLimit: 8_000_000,
gasPrice: BigNumber.from(0),
data: '0x',
value: 0,
}
}
export const gasPriceForL2 = async () => {
if (procEnv.L2_GAS_PRICE === ON_CHAIN_GAS_PRICE) {
return l2Wallet.getGasPrice()
}
return utils.parseUnits(procEnv.L2_GAS_PRICE, 'wei')
}
export const gasPriceForL1 = async () => {
if (procEnv.L1_GAS_PRICE === ON_CHAIN_GAS_PRICE) {
return l1Wallet.getGasPrice()
}
return utils.parseUnits(procEnv.L1_GAS_PRICE, 'wei')
}
export const isHardhat = async () => {
const chainId = await l1Wallet.getChainId()
return chainId === HARDHAT_CHAIN_ID
}
export const die = (...args) => {
console.log(...args)
process.exit(1)
}
export const logStderr = (msg: string) => {
process.stderr.write(`${msg}\n`)
}
integration-tests/test/stress-tests.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { Contract, Wallet, utils } from 'ethers'
import { ethers } from 'hardhat'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import {
executeL1ToL2TransactionsParallel,
executeL2ToL1TransactionsParallel,
executeL2TransactionsParallel,
executeRepeatedL1ToL2Transactions,
executeRepeatedL2ToL1Transactions,
executeRepeatedL2Transactions,
fundRandomWallet,
} from './shared/stress-test-helpers'
/* Imports: Artifacts */
import { envConfig, fundUser } from './shared/utils'
// Need a big timeout to allow for all transactions to be processed.
// For some reason I can't figure out how to set the timeout on a per-suite basis
// so I'm instead setting it for every test.
const STRESS_TEST_TIMEOUT = envConfig.MOCHA_TIMEOUT * 5
describe('stress tests', () => {
const numTransactions = 3
let env: OptimismEnv
const wallets: Wallet[] = []
before(async function () {
if (!envConfig.RUN_STRESS_TESTS) {
console.log('Skipping stress tests.')
this.skip()
return
}
env = await OptimismEnv.new()
for (let i = 0; i < numTransactions; i++) {
wallets.push(Wallet.createRandom())
}
for (const wallet of wallets) {
await fundRandomWallet(env, wallet, utils.parseEther('0.1'))
}
for (const wallet of wallets) {
await fundUser(env.messenger, utils.parseEther('0.1'), wallet.address)
}
})
let L2SimpleStorage: Contract
let L1SimpleStorage: Contract
beforeEach(async () => {
const factory__L1SimpleStorage = await ethers.getContractFactory(
'SimpleStorage',
env.l1Wallet
)
const factory__L2SimpleStorage = await ethers.getContractFactory(
'SimpleStorage',
env.l2Wallet
)
L1SimpleStorage = await factory__L1SimpleStorage.deploy()
await L1SimpleStorage.deployTransaction.wait()
L2SimpleStorage = await factory__L2SimpleStorage.deploy()
await L2SimpleStorage.deployTransaction.wait()
})
describe('L1 => L2 stress tests', () => {
it(`${numTransactions} L1 => L2 transactions (serial)`, async () => {
await executeRepeatedL1ToL2Transactions(env, wallets, {
contract: L2SimpleStorage,
functionName: 'setValue',
functionParams: [`0x${'42'.repeat(32)}`],
})
expect((await L2SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length
)
}).timeout(STRESS_TEST_TIMEOUT)
it(`${numTransactions} L1 => L2 transactions (parallel)`, async () => {
await executeL1ToL2TransactionsParallel(env, wallets, {
contract: L2SimpleStorage,
functionName: 'setValue',
functionParams: [`0x${'42'.repeat(32)}`],
})
expect((await L2SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length
)
}).timeout(STRESS_TEST_TIMEOUT)
})
describe('L2 => L1 stress tests', () => {
it(`${numTransactions} L2 => L1 transactions (serial)`, async () => {
await executeRepeatedL2ToL1Transactions(env, wallets, {
contract: L1SimpleStorage,
functionName: 'setValue',
functionParams: [`0x${'42'.repeat(32)}`],
})
expect((await L1SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length
)
}).timeout(STRESS_TEST_TIMEOUT)
it(`${numTransactions} L2 => L1 transactions (parallel)`, async () => {
await executeL2ToL1TransactionsParallel(env, wallets, {
contract: L1SimpleStorage,
functionName: 'setValue',
functionParams: [`0x${'42'.repeat(32)}`],
})
expect((await L1SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length
)
}).timeout(STRESS_TEST_TIMEOUT)
})
describe('L2 transaction stress tests', () => {
it(`${numTransactions} L2 transactions (serial)`, async () => {
await executeRepeatedL2Transactions(env, wallets, {
contract: L2SimpleStorage,
functionName: 'setValueNotXDomain',
functionParams: [`0x${'42'.repeat(32)}`],
})
expect((await L2SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length
)
}).timeout(STRESS_TEST_TIMEOUT)
it(`${numTransactions} L2 transactions (parallel)`, async () => {
await executeL2TransactionsParallel(env, wallets, {
contract: L2SimpleStorage,
functionName: 'setValueNotXDomain',
functionParams: [`0x${'42'.repeat(32)}`],
})
expect((await L2SimpleStorage.totalCount()).toNumber()).to.equal(
numTransactions
)
}).timeout(STRESS_TEST_TIMEOUT)
})
describe('C-C-C-Combo breakers', () => {
it(`${numTransactions} L2 transactions, L1 => L2 transactions, L2 => L1 transactions (txs serial, suites parallel)`, async () => {
await Promise.all([
executeRepeatedL1ToL2Transactions(env, wallets, {
contract: L2SimpleStorage,
functionName: 'setValue',
functionParams: [`0x${'42'.repeat(32)}`],
}),
executeRepeatedL2ToL1Transactions(env, wallets, {
contract: L1SimpleStorage,
functionName: 'setValue',
functionParams: [`0x${'42'.repeat(32)}`],
}),
executeRepeatedL2Transactions(env, wallets, {
contract: L2SimpleStorage,
functionName: 'setValueNotXDomain',
functionParams: [`0x${'42'.repeat(32)}`],
}),
])
expect((await L2SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length * 2
)
expect((await L1SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length
)
}).timeout(STRESS_TEST_TIMEOUT)
it(`${numTransactions} L2 transactions, L1 => L2 transactions, L2 => L1 transactions (all parallel)`, async () => {
await Promise.all([
executeL1ToL2TransactionsParallel(env, wallets, {
contract: L2SimpleStorage,
functionName: 'setValue',
functionParams: [`0x${'42'.repeat(32)}`],
}),
executeL2ToL1TransactionsParallel(env, wallets, {
contract: L1SimpleStorage,
functionName: 'setValue',
functionParams: [`0x${'42'.repeat(32)}`],
}),
executeL2TransactionsParallel(env, wallets, {
contract: L2SimpleStorage,
functionName: 'setValueNotXDomain',
functionParams: [`0x${'42'.repeat(32)}`],
}),
])
expect((await L2SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length * 2
)
expect((await L1SimpleStorage.totalCount()).toNumber()).to.equal(
wallets.length
)
}).timeout(STRESS_TEST_TIMEOUT)
})
// These tests depend on an archive node due to the historical `eth_call`s
describe('Monotonicity Checks', () => {
it('should have monotonic timestamps and l1 blocknumbers', async () => {
const tip = await env.l2Provider.getBlock('latest')
const prev = {
block: await env.l2Provider.getBlock(0),
l1BlockNumber:
await env.messenger.contracts.l2.OVM_L1BlockNumber.getL1BlockNumber({
blockTag: 0,
}),
}
for (let i = 1; i < tip.number; i++) {
const block = await env.l2Provider.getBlock(i)
expect(block.timestamp).to.be.gte(prev.block.timestamp)
const l1BlockNumber =
await env.messenger.contracts.l2.OVM_L1BlockNumber.getL1BlockNumber({
blockTag: i,
})
expect(l1BlockNumber.gt(prev.l1BlockNumber))
prev.block = block
prev.l1BlockNumber = l1BlockNumber
}
})
})
})
integration-tests/test/system-addresses.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { BigNumber, Contract, ContractFactory, utils, Wallet } from 'ethers'
import { ethers } from 'hardhat'
import { futurePredeploys } from '@eth-optimism/contracts'
import { sleep } from '@eth-optimism/core-utils'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import { envConfig } from './shared/utils'
const SYSTEM_ADDRESSES = [futurePredeploys.System0, futurePredeploys.System1]
describe('System addresses', () => {
let env: OptimismEnv
let deployerWallets: Wallet[] = []
let contracts: Contract[]
let Factory__ERC20: ContractFactory
before(async function () {
if (!envConfig.RUN_SYSTEM_ADDRESS_TESTS) {
console.log('Skipping system address tests.')
this.skip()
return
}
env = await OptimismEnv.new()
deployerWallets = [
new Wallet(process.env.SYSTEM_ADDRESS_0_DEPLOYER_KEY, env.l2Provider),
new Wallet(process.env.SYSTEM_ADDRESS_1_DEPLOYER_KEY, env.l2Provider),
]
for (const deployer of deployerWallets) {
await env.l2Wallet.sendTransaction({
to: deployer.address,
value: utils.parseEther('0.1'),
})
}
contracts = []
Factory__ERC20 = await ethers.getContractFactory('ERC20', env.l2Wallet)
})
it('should have no code for the system addresses initially', async () => {
for (const addr of SYSTEM_ADDRESSES) {
const code = await env.l2Provider.getCode(addr, 'latest')
expect(code).to.eq('0x')
}
})
it('should deploy to the system address', async () => {
for (let i = 0; i < deployerWallets.length; i++) {
const contract = await Factory__ERC20.connect(deployerWallets[i]).deploy(
100000000,
'OVM Test',
8,
'OVM'
)
// have to use the receipt here since ethers calculates the
// contract address on-the-fly
const receipt = await contract.deployTransaction.wait()
expect(receipt.contractAddress).to.eq(SYSTEM_ADDRESSES[i])
const fetchedReceipt = await env.l2Provider.getTransactionReceipt(
receipt.transactionHash
)
expect(fetchedReceipt.contractAddress).to.eq(SYSTEM_ADDRESSES[i])
contracts.push(await ethers.getContractAt('ERC20', SYSTEM_ADDRESSES[i]))
}
})
it('contracts deployed at the system addresses should function', async () => {
expect(contracts.length).to.eq(2)
for (let i = 0; i < contracts.length; i++) {
const wallet = deployerWallets[i]
const contract = contracts[i].connect(wallet)
const code = await env.l2Provider.getCode(contract.address, 'latest')
expect(code).not.to.eq('0x')
const tx = await contract.transfer(env.l2Wallet.address, 1000)
await tx.wait()
const bal = await contract.balanceOf(env.l2Wallet.address)
expect(bal).to.deep.equal(BigNumber.from(1000))
}
})
it('should not deploy any additional contracts from the deployer at the system address', async () => {
for (let i = 0; i < deployerWallets.length; i++) {
const contract = await Factory__ERC20.connect(deployerWallets[i]).deploy(
100000000,
'OVM Test',
8,
'OVM'
)
await contract.deployed()
const receipt = await contract.deployTransaction.wait()
expect(receipt.contractAddress).not.to.eq(SYSTEM_ADDRESSES[i])
expect(receipt.contractAddress).not.to.eq(null)
}
})
const testReplica = async (otherProvider) => {
const seqBlock = await env.l2Provider.getBlock('latest')
while (true) {
const verHeight = await otherProvider.getBlockNumber()
if (verHeight >= seqBlock.number) {
break
}
await sleep(200)
}
const verBlock = await otherProvider.getBlock(seqBlock.number)
expect(verBlock).to.deep.eq(seqBlock)
for (const addr of SYSTEM_ADDRESSES) {
const seqCode = await env.l2Provider.getCode(addr)
const verCode = await otherProvider.getCode(addr)
expect(seqCode).to.eq(verCode)
}
}
it('should be properly handled on verifiers', async function () {
if (!envConfig.RUN_VERIFIER_TESTS) {
this.skip()
return
}
await testReplica(env.verifierProvider)
})
it('should be properly handled on replicas', async function () {
if (!envConfig.RUN_REPLICA_TESTS) {
this.skip()
return
}
await testReplica(env.replicaProvider)
})
})
integration-tests/test/verifier.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { TransactionReceipt } from '@ethersproject/abstract-provider'
import { sleep } from '@eth-optimism/core-utils'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import {
defaultTransactionFactory,
gasPriceForL2,
envConfig,
} from './shared/utils'
describe('Verifier Tests', () => {
let env: OptimismEnv
before(async function () {
if (!envConfig.RUN_VERIFIER_TESTS) {
this.skip()
return
}
env = await OptimismEnv.new()
})
describe('Matching blocks', () => {
it('should sync a transaction', async () => {
const tx = defaultTransactionFactory()
tx.gasPrice = await gasPriceForL2()
const result = await env.l2Wallet.sendTransaction(tx)
let receipt: TransactionReceipt
while (!receipt) {
receipt = await env.verifierProvider.getTransactionReceipt(result.hash)
await sleep(200)
}
const sequencerBlock = (await env.l2Provider.getBlock(
result.blockNumber
)) as any
const verifierBlock = (await env.verifierProvider.getBlock(
result.blockNumber
)) as any
expect(sequencerBlock.stateRoot).to.deep.eq(verifierBlock.stateRoot)
expect(sequencerBlock.hash).to.deep.eq(verifierBlock.hash)
})
it('sync an unprotected tx (eip155)', async () => {
const tx = {
...defaultTransactionFactory(),
nonce: await env.l2Wallet.getTransactionCount(),
gasPrice: await gasPriceForL2(),
chainId: null, // Disables EIP155 transaction signing.
}
const signed = await env.l2Wallet.signTransaction(tx)
const result = await env.l2Provider.sendTransaction(signed)
let receipt: TransactionReceipt
while (!receipt) {
receipt = await env.verifierProvider.getTransactionReceipt(result.hash)
await sleep(200)
}
const sequencerBlock = (await env.l2Provider.getBlock(
result.blockNumber
)) as any
const verifierBlock = (await env.verifierProvider.getBlock(
result.blockNumber
)) as any
expect(sequencerBlock.stateRoot).to.deep.eq(verifierBlock.stateRoot)
expect(sequencerBlock.hash).to.deep.eq(verifierBlock.hash)
})
it('should forward tx to sequencer', async () => {
const tx = {
...defaultTransactionFactory(),
nonce: await env.l2Wallet.getTransactionCount(),
gasPrice: await gasPriceForL2(),
}
const signed = await env.l2Wallet.signTransaction(tx)
const result = await env.verifierProvider.sendTransaction(signed)
let receipt: TransactionReceipt
while (!receipt) {
receipt = await env.verifierProvider.getTransactionReceipt(result.hash)
await sleep(200)
}
const sequencerBlock = (await env.l2Provider.getBlock(
result.blockNumber
)) as any
const verifierBlock = (await env.verifierProvider.getBlock(
result.blockNumber
)) as any
expect(sequencerBlock.stateRoot).to.deep.eq(verifierBlock.stateRoot)
expect(sequencerBlock.hash).to.deep.eq(verifierBlock.hash)
})
})
})
integration-tests/test/whitelist.spec.ts deleted 100644 → 0
View file @ cccce791
/* Imports: External */
import { ContractFactory } from 'ethers'
import { ethers } from 'hardhat'
import { predeploys } from '@eth-optimism/contracts'
/* Imports: Internal */
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
describe('Whitelist', async () => {
const initialAmount = 1000
const tokenName = 'OVM Test'
const tokenDecimals = 8
const TokenSymbol = 'OVM'
let Factory__ERC20: ContractFactory
let env: OptimismEnv
before(async () => {
env = await OptimismEnv.new()
Factory__ERC20 = await ethers.getContractFactory('ERC20', env.l2Wallet)
})
describe('when the whitelist is disabled', () => {
it('should be able to deploy a contract', async () => {
await expect(
env.l2Provider.send('eth_call', [
Factory__ERC20.getDeployTransaction(
initialAmount,
tokenName,
tokenDecimals,
TokenSymbol
),
'latest',
{
[predeploys.OVM_DeployerWhitelist]: {
state: {
['0x0000000000000000000000000000000000000000000000000000000000000000']:
'0x0000000000000000000000000000000000000000000000000000000000000000',
},
},
},
])
).to.not.be.reverted
})
})
describe('when the whitelist is enabled', () => {
const sender = '0x' + '22'.repeat(20)
it('should fail if the user is not whitelisted', async () => {
await expect(
env.l2Provider.send('eth_call', [
{
...Factory__ERC20.getDeployTransaction(
initialAmount,
tokenName,
tokenDecimals,
TokenSymbol
),
from: sender,
},
'latest',
{
[predeploys.OVM_DeployerWhitelist]: {
state: {
// Set an owner but don't allow this user to deploy
// Owner here is address(1) instead of address(0)
['0x0000000000000000000000000000000000000000000000000000000000000000']:
'0x0000000000000000000000000000000000000000000000000000000000000001',
},
},
},
])
).to.be.revertedWith(`deployer address not whitelisted: ${sender}`)
})
it('should succeed if the user is whitelisted', async () => {
await expect(
env.l2Provider.send('eth_call', [
{
...Factory__ERC20.getDeployTransaction(
initialAmount,
tokenName,
tokenDecimals,
TokenSymbol
),
from: sender,
},
'latest',
{
[predeploys.OVM_DeployerWhitelist]: {
state: {
// Set an owner
['0x0000000000000000000000000000000000000000000000000000000000000000']:
'0x0000000000000000000000000000000000000000000000000000000000000001',
// See https://docs.soliditylang.org/en/v0.8.9/internals/layout_in_storage.html for
// reference on how the correct storage slot should be set.
// Whitelist mapping is located at storage slot 1.
// whitelist[address] will be located at:
// keccak256(uint256(address) . uint256(1)))
[ethers.utils.keccak256(
'0x' +
// uint256(address)
'0000000000000000000000002222222222222222222222222222222222222222' +
// uint256(1)
'0000000000000000000000000000000000000000000000000000000000000001'
)]:
'0x0000000000000000000000000000000000000000000000000000000000000001', // Boolean (1)
},
},
},
])
).to.not.be.reverted
})
})
})
integration-tests/test/z-batch-serialization.spec.ts deleted 100644 → 0
View file @ cccce791
import { SequencerBatch, BatchType } from '@eth-optimism/core-utils'
import { expect } from './shared/setup'
import { OptimismEnv } from './shared/env'
import { envConfig } from './shared/utils'
describe('Batch Serialization', () => {
let env: OptimismEnv
// Allow for each type to be tested. The env var here must be
// the same value that is passed to the batch submitter
const batchType = envConfig.BATCH_SUBMITTER_SEQUENCER_BATCH_TYPE.toUpperCase()
before(async () => {
env = await OptimismEnv.new()
})
it('should fetch batches', async () => {
const tip = await env.l1Provider.getBlockNumber()
const ctc = env.messenger.contracts.l1.CanonicalTransactionChain
const logs = await ctc.queryFilter(
ctc.filters.TransactionBatchAppended(),
0,
tip
)
// collect all of the batches
const batches = []
for (const log of logs) {
const tx = await env.l1Provider.getTransaction(log.transactionHash)
batches.push(tx.data)
}
expect(batches.length).to.be.gt(0, 'Submit some batches first')
let latest = 0
// decode all of the batches
for (const batch of batches) {
// Typings don't work?
const decoded = (SequencerBatch as any).fromHex(batch)
expect(decoded.type).to.eq(BatchType[batchType])
// Iterate over all of the transactions, fetch them
// by hash and make sure their blocknumbers are in
// ascending order. This lets us skip handling deposits here
for (const transaction of decoded.transactions) {
const tx = transaction.toTransaction()
const got = await env.l2Provider.getTransaction(tx.hash)
expect(got).to.not.eq(null)
expect(got.blockNumber).to.be.gt(latest)
latest = got.blockNumber
}
}
})
})
integration-tests/tsconfig.json deleted 100644 → 0
View file @ cccce791
{
"extends": "../tsconfig.json",
"compilerOptions": {
"resolveJsonModule": true
},
"include": [
"./test",
"sync-tests/*.ts",
"./actor-tests/**/*.ts",
"./artifacts/**/*.json",
"./tasks/**/*.ts",
"./package.json"
],
"files": ["./hardhat.config.ts"]
}
ops-bedrock/test-integration.sh deleted 100755 → 0
View file @ cccce791
#!/usr/bin/env bash
# This script starts the integration tests using the deployed contracts. The script
# takes one argument: a path to the deployments directory.
set -eu
DEPLOYMENTS_DIR="$1"
if [ ! -f "$DEPLOYMENTS_DIR/OptimismPortal.json" ]; then
echo "Deployment directory $DEPLOYMENTS_DIR not found. Please "
echo "check the path, then try again."
fi
export OPTIMISM_PORTAL_ADDRESS=$(jq -r '.address' < "$DEPLOYMENTS_DIR/OptimismPortal.json")
cd ./packages/integration-tests-bedrock
yarn test
ops/docker-compose.yml
View file @ f63e3231
......@@ -207,32 +207,6 @@ services:
ports:
- ${HEALTHCHECK_HTTP_PORT:-7300}:7300
integration_tests:
deploy:
replicas: 0
build:
context: ..
dockerfile: ./ops/docker/Dockerfile.packages
target: integration-tests
image: ethereumoptimism/integration-tests:${DOCKER_TAG_INTEGRATION_TESTS:-latest}
entrypoint: ./integration-tests.sh
environment:
L1_URL: http://l1_chain:8545
L2_URL: http://l2geth:8545
HEALTHCHECK_URL: http://replica_healthcheck:7300/metrics
REPLICA_URL: http://replica:8545
VERIFIER_URL: http://verifier:8545
URL: http://deployer:8081/addresses.json
ENABLE_GAS_REPORT: 1
NO_NETWORK: 1
BATCH_SUBMITTER_SEQUENCER_BATCH_TYPE: ${BATCH_SUBMITTER_SEQUENCER_BATCH_TYPE:-zlib}
RUN_SYSTEM_ADDRESS_TESTS: 'true'
# must match l2geth environment, see above for why it's safe to publish these
SYSTEM_ADDRESS_0_DEPLOYER_KEY: 'a6aecc98b63bafb0de3b29ae9964b14acb4086057808be29f90150214ebd4a0f'
SYSTEM_ADDRESS_1_DEPLOYER_KEY: '3b8d2345102cce2443acb240db6e87c8edd4bb3f821b17fab8ea2c9da08ea132'
gas_oracle:
deploy:
replicas: 0
......
ops/docker/Dockerfile.packages
View file @ f63e3231
......@@ -60,14 +60,12 @@ WORKDIR /opt/optimism
# Copy manifest files into the image in
# preparation for `yarn install`.
COPY integration-tests/package.json ./integration-tests/package.json
COPY --from=manifests /tmp/manifests ./
COPY *.json ./
RUN yarn install --frozen-lockfile && yarn cache clean
COPY ./packages ./packages
COPY ./integration-tests ./integration-tests
RUN yarn build
......@@ -95,11 +93,6 @@ WORKDIR /opt/optimism/packages/data-transport-layer
COPY ./ops/scripts/dtl.sh .
CMD ["node", "dist/src/services/run.js"]
FROM base as integration-tests
WORKDIR /opt/optimism/integration-tests
COPY ./ops/scripts/integration-tests.sh ./
CMD ["yarn", "test:integration"]
FROM base as message-relayer
WORKDIR /opt/optimism/packages/message-relayer
......
ops/scripts/build-ci.sh
View file @ f63e3231
......@@ -24,6 +24,5 @@ build deployer "ethereumoptimism/deployer:latest" "./ops/docker/Dockerfile.deplo
build dtl "ethereumoptimism/data-transport-layer:latest" "./ops/docker/Dockerfile.data-transport-layer" .
build relayer "ethereumoptimism/message-relayer:latest" "./ops/docker/Dockerfile.message-relayer" .
build relayer "ethereumoptimism/fault-detector:latest" "./ops/docker/Dockerfile.fault-detector" .
build integration-tests "ethereumoptimism/integration-tests:latest" "./ops/docker/Dockerfile.integration-tests" .
wait
package.json
View file @ f63e3231
......@@ -9,7 +9,6 @@
"batch-submitter",
"bss-core",
"gas-oracle",
"integration-tests",
"l2geth-exporter",
"l2geth",
"ops/docker/rpc-proxy",
......
yarn.lock
View file @ f63e3231
......@@ -59,7 +59,7 @@
semver "^6.3.0"
source-map "^0.5.0"
"@babel/eslint-parser@^7.18.2", "@babel/eslint-parser@^7.5.4":
"@babel/eslint-parser@^7.18.2":
version "7.18.2"
resolved "https://registry.yarnpkg.com/@babel/eslint-parser/-/eslint-parser-7.18.2.tgz#e14dee36c010edfb0153cf900c2b0815e82e3245"
integrity sha512-oFQYkE8SuH14+uR51JVAmdqwKYXGRjEXx7s+WiagVjqQ+HPE+nnwyF2qlVG8evUsUHmPcA+6YXMEDbIhEyQc5A==
......@@ -1227,21 +1227,6 @@
"@ethersproject/properties" "^5.7.0"
"@ethersproject/strings" "^5.7.0"
"@ethersproject/abi@^5.0.12":
version "5.4.1"
resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.4.1.tgz#6ac28fafc9ef6f5a7a37e30356a2eb31fa05d39b"
integrity sha512-9mhbjUk76BiSluiiW4BaYyI58KSbDMMQpCLdsAR+RsT2GyATiNYxVv+pGWRrekmsIdY3I+hOqsYQSTkc8L/mcg==
dependencies:
"@ethersproject/address" "^5.4.0"
"@ethersproject/bignumber" "^5.4.0"
"@ethersproject/bytes" "^5.4.0"
"@ethersproject/constants" "^5.4.0"
"@ethersproject/hash" "^5.4.0"
"@ethersproject/keccak256" "^5.4.0"
"@ethersproject/logger" "^5.4.0"
"@ethersproject/properties" "^5.4.0"
"@ethersproject/strings" "^5.4.0"
"@ethersproject/abstract-provider@5.4.1", "@ethersproject/abstract-provider@^5.4.0":
version "5.4.1"
resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.4.1.tgz#e404309a29f771bd4d28dbafadcaa184668c2a6e"
......@@ -2001,7 +1986,7 @@
elliptic "6.5.4"
hash.js "1.1.7"
"@ethersproject/solidity@5.4.0", "@ethersproject/solidity@^5.0.9":
"@ethersproject/solidity@5.4.0":
version "5.4.0"
resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.4.0.tgz#1305e058ea02dc4891df18b33232b11a14ece9ec"
integrity sha512-XFQTZ7wFSHOhHcV1DpcWj7VXECEiSrBuv7JErJvB9Uo+KfCdc3QtUZV+Vjh/AAaYgezUEKbCtE6Khjm44seevQ==
......@@ -3627,11 +3612,6 @@
resolved "https://registry.yarnpkg.com/@openzeppelin/contracts-upgradeable/-/contracts-upgradeable-4.7.3.tgz#f1d606e2827d409053f3e908ba4eb8adb1dd6995"
integrity sha512-+wuegAMaLcZnLCJIvrVUDzA9z/Wp93f0Dla/4jJvIhijRrPabjQbZe6fWiECLaJyfn5ci9fqf9vTw3xpQOad2A==
"@openzeppelin/contracts@3.4.1-solc-0.7-2":
version "3.4.1-solc-0.7-2"
resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-3.4.1-solc-0.7-2.tgz#371c67ebffe50f551c3146a9eec5fe6ffe862e92"
integrity sha512-tAG9LWg8+M2CMu7hIsqHPaTyG4uDzjr6mhvH96LvOpLZZj6tgzTluBt+LsCf1/QaYrlis6pITvpIaIhE+iZB+Q==
"@openzeppelin/contracts@4.3.2":
version "4.3.2"
resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.3.2.tgz#ff80affd6d352dbe1bbc5b4e1833c41afd6283b6"
......@@ -3642,11 +3622,6 @@
resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.7.3.tgz#939534757a81f8d69cc854c7692805684ff3111e"
integrity sha512-dGRS0agJzu8ybo44pCIf3xBaPQN/65AIXNgK8+4gzKd5kbvlqyxryUYVLJv7fK98Seyd2hDZzVEHSWAh0Bt1Yw==
"@openzeppelin/contracts@^4.4.0":
version "4.4.0"
resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.4.0.tgz#4a1df71f736c31230bbbd634dfb006a756b51e6b"
integrity sha512-dlKiZmDvJnGRLHojrDoFZJmsQVeltVeoiRN7RK+cf2FmkhASDEblE0RiaYdxPNsUZa6mRG8393b9bfyp+V5IAw==
"@pedrouid/environment@^1.0.1":
version "1.0.1"
resolved "https://registry.yarnpkg.com/@pedrouid/environment/-/environment-1.0.1.tgz#858f0f8a057340e0b250398b75ead77d6f4342ec"
......@@ -4423,7 +4398,7 @@
dependencies:
"@types/node" "*"
"@types/glob@*", "@types/glob@^7.1.1":
"@types/glob@^7.1.1":
version "7.1.4"
resolved "https://registry.yarnpkg.com/@types/glob/-/glob-7.1.4.tgz#ea59e21d2ee5c517914cb4bc8e4153b99e566672"
integrity sha512-w+LsMxKyYQm347Otw+IfBXOv9UWVjpHpCDdbBMt8Kz/xbvCYNjP+0qPh91Km3iKfSRLBB0P7fAMf0KHrPu+MyA==
......@@ -4683,14 +4658,6 @@
dependencies:
"@types/node" "*"
"@types/rimraf@^3.0.0":
version "3.0.2"
resolved "https://registry.yarnpkg.com/@types/rimraf/-/rimraf-3.0.2.tgz#a63d175b331748e5220ad48c901d7bbf1f44eef8"
integrity sha512-F3OznnSLAUxFrCEu/L5PY8+ny8DtcFRjx7fZZ9bycvXRi3KPTRS9HOitGZwvPg0juRhXFWIeKX58cnX5YqLohQ==
dependencies:
"@types/glob" "*"
"@types/node" "*"
"@types/secp256k1@^4.0.1":
version "4.0.3"
resolved "https://registry.yarnpkg.com/@types/secp256k1/-/secp256k1-4.0.3.tgz#1b8e55d8e00f08ee7220b4d59a6abe89c37a901c"
......@@ -4854,67 +4821,6 @@
resolved "https://registry.yarnpkg.com/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz#aa58042711d6e3275dd37dc597e5d31e8c290a44"
integrity sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==
"@uniswap/lib@^4.0.1-alpha":
version "4.0.1-alpha"
resolved "https://registry.yarnpkg.com/@uniswap/lib/-/lib-4.0.1-alpha.tgz#2881008e55f075344675b3bca93f020b028fbd02"
integrity sha512-f6UIliwBbRsgVLxIaBANF6w09tYqc6Y/qXdsrbEmXHyFA7ILiKrIwRFXe1yOg8M3cksgVsO9N7yuL2DdCGQKBA==
"@uniswap/sdk-core@^3.0.1":
version "3.0.1"
resolved "https://registry.yarnpkg.com/@uniswap/sdk-core/-/sdk-core-3.0.1.tgz#d08dd68257983af64b9a5f4d6b9cf26124b4138f"
integrity sha512-WbeDkhZ9myVR0VnHOdTrb8nHKKkqTFa5uE9RvUbG3eyDt2NWWDwhhqGHwAWJEHG405l30Fa1u3PogHDFsIOQlA==
dependencies:
"@ethersproject/address" "^5.0.2"
big.js "^5.2.2"
decimal.js-light "^2.5.0"
jsbi "^3.1.4"
tiny-invariant "^1.1.0"
toformat "^2.0.0"
"@uniswap/v2-core@1.0.1":
version "1.0.1"
resolved "https://registry.yarnpkg.com/@uniswap/v2-core/-/v2-core-1.0.1.tgz#af8f508bf183204779938969e2e54043e147d425"
integrity sha512-MtybtkUPSyysqLY2U210NBDeCHX+ltHt3oADGdjqoThZaFRDKwM6k1Nb3F0A3hk5hwuQvytFWhrWHOEq6nVJ8Q==
"@uniswap/v3-core@1.0.0":
version "1.0.0"
resolved "https://registry.yarnpkg.com/@uniswap/v3-core/-/v3-core-1.0.0.tgz#6c24adacc4c25dceee0ba3ca142b35adbd7e359d"
integrity sha512-kSC4djMGKMHj7sLMYVnn61k9nu+lHjMIxgg9CDQT+s2QYLoA56GbSK9Oxr+qJXzzygbkrmuY6cwgP6cW2JXPFA==
"@uniswap/v3-periphery@^1.0.1", "@uniswap/v3-periphery@^1.1.1":
version "1.2.1"
resolved "https://registry.yarnpkg.com/@uniswap/v3-periphery/-/v3-periphery-1.2.1.tgz#7775630bea774a2cf989ab87ce3c328ac52e0d50"
integrity sha512-45W8hT8X1j9ZcXa+y3NSVao90hMZtgtoJyDlMOg91wmUGi2idXAiGivOQYdB7+7Lq8Gc6Upv/ggFZknixZrv7g==
dependencies:
"@openzeppelin/contracts" "3.4.1-solc-0.7-2"
"@uniswap/lib" "^4.0.1-alpha"
"@uniswap/v2-core" "1.0.1"
"@uniswap/v3-core" "1.0.0"
base64-sol "1.0.1"
hardhat-watcher "^2.1.1"
"@uniswap/v3-sdk@^3.6.2":
version "3.6.2"
resolved "https://registry.yarnpkg.com/@uniswap/v3-sdk/-/v3-sdk-3.6.2.tgz#45fa659f7642e8807cb36939e4426355c7a5943c"
integrity sha512-RHJaFfO6+ugI0+v0xhGXuVadmJ9bTbAz/RnuS/xRpXrRIsLNRVC42bYZ3Ci0JPWhkaNygCcc3LJ36Bs6GganSg==
dependencies:
"@ethersproject/abi" "^5.0.12"
"@ethersproject/solidity" "^5.0.9"
"@uniswap/sdk-core" "^3.0.1"
"@uniswap/v3-periphery" "^1.1.1"
"@uniswap/v3-staker" "1.0.0"
tiny-invariant "^1.1.0"
tiny-warning "^1.0.3"
"@uniswap/v3-staker@1.0.0":
version "1.0.0"
resolved "https://registry.yarnpkg.com/@uniswap/v3-staker/-/v3-staker-1.0.0.tgz#9a6915ec980852479dfc903f50baf822ff8fa66e"
integrity sha512-JV0Qc46Px5alvg6YWd+UIaGH9lDuYG/Js7ngxPit1SPaIP30AlVer1UYB7BRYeUVVxE+byUyIeN5jeQ7LLDjIw==
dependencies:
"@openzeppelin/contracts" "3.4.1-solc-0.7-2"
"@uniswap/v3-core" "1.0.0"
"@uniswap/v3-periphery" "^1.0.1"
"@vitest/expect@0.28.3":
version "0.28.3"
resolved "https://registry.yarnpkg.com/@vitest/expect/-/expect-0.28.3.tgz#8cd570b662e709f56ba29835879890c87429a194"
......@@ -6814,11 +6720,6 @@ base64-js@^1.3.1:
resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
base64-sol@1.0.1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/base64-sol/-/base64-sol-1.0.1.tgz#91317aa341f0bc763811783c5729f1c2574600f6"
integrity sha512-ld3cCNMeXt4uJXmLZBHFGMvVpK9KsLVEhPpFRXnvSVAqABKbuNZg/+dsq3NuM+wxFLb/UrVkz7m1ciWmkMfTbg==
base@^0.11.1:
version "0.11.2"
resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
......@@ -6887,11 +6788,6 @@ bfj@^7.0.2:
hoopy "^0.1.4"
tryer "^1.0.1"
big.js@^5.2.2:
version "5.2.2"
resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
bigint-buffer@^1.1.5:
version "1.1.5"
resolved "https://registry.yarnpkg.com/bigint-buffer/-/bigint-buffer-1.1.5.tgz#d038f31c8e4534c1f8d0015209bf34b4fa6dd442"
......@@ -7728,7 +7624,7 @@ chokidar@3.5.3, "chokidar@>=3.0.0 <4.0.0", chokidar@^3.5.1, chokidar@^3.5.3:
optionalDependencies:
fsevents "~2.3.2"
chokidar@^3.4.0, chokidar@^3.4.3, chokidar@^3.5.2:
chokidar@^3.4.0, chokidar@^3.5.2:
version "3.5.2"
resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.2.tgz#dba3976fcadb016f66fd365021d91600d01c1e75"
integrity sha512-ekGhOnNVPgT77r4K/U3GDhu+FQ2S8TnK/s2KbIGXi0SZWuwkZ2QNyfWdZW+TVfn84DpEP7rLeCt2UI6bJ8GwbQ==
......@@ -7850,16 +7746,6 @@ cli-table3@^0.5.0:
optionalDependencies:
colors "^1.1.2"
cli-table3@^0.6.0:
version "0.6.0"
resolved "https://registry.yarnpkg.com/cli-table3/-/cli-table3-0.6.0.tgz#b7b1bc65ca8e7b5cef9124e13dc2b21e2ce4faee"
integrity sha512-gnB85c3MGC7Nm9I/FkiasNBOKjOiO1RNuXXarQms37q4QMpWdlbBgD/VnOStA2faG1dpXMv31RFApjX1/QdgWQ==
dependencies:
object-assign "^4.1.0"
string-width "^4.2.0"
optionalDependencies:
colors "^1.1.2"
cli-table@^0.3.1:
version "0.3.6"
resolved "https://registry.yarnpkg.com/cli-table/-/cli-table-0.3.6.tgz#e9d6aa859c7fe636981fd3787378c2a20bce92fc"
......@@ -8671,11 +8557,6 @@ decamelize@^4.0.0:
resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-4.0.0.tgz#aa472d7bf660eb15f3494efd531cab7f2a709837"
integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==
decimal.js-light@^2.5.0:
version "2.5.1"
resolved "https://registry.yarnpkg.com/decimal.js-light/-/decimal.js-light-2.5.1.tgz#134fd32508f19e208f4fb2f8dac0d2626a867934"
integrity sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==
decimal.js@^10.4.2:
version "10.4.3"
resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.4.3.tgz#1044092884d245d1b7f65725fa4ad4c6f781cc23"
......@@ -9308,13 +9189,6 @@ env-paths@^2.2.0:
resolved "https://registry.yarnpkg.com/env-paths/-/env-paths-2.2.1.tgz#420399d416ce1fbe9bc0a07c62fa68d67fd0f8f2"
integrity sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==
envalid@^7.1.0:
version "7.2.1"
resolved "https://registry.yarnpkg.com/envalid/-/envalid-7.2.1.tgz#7e9e62f3bc1ed209517f65b563e24c7b79c9793b"
integrity sha512-NU0ty82LSvHF+Uio9cLNKhrDyivFv7GSvhOu91WbtOOyNKRzXWeDZaopldXJkGBAZ5UuquqXp6VBUXuTfXrUrw==
dependencies:
tslib "2.3.1"
envalid@^7.2.2:
version "7.2.2"
resolved "https://registry.yarnpkg.com/envalid/-/envalid-7.2.2.tgz#f3219f85e692002dca0f28076740227d30c817e3"
......@@ -12332,13 +12206,6 @@ hardhat-output-validator@^0.1.18:
dependencies:
chalk "^4.1.2"
hardhat-watcher@^2.1.1:
version "2.1.1"
resolved "https://registry.yarnpkg.com/hardhat-watcher/-/hardhat-watcher-2.1.1.tgz#8b05fec429ed45da11808bbf6054a90f3e34c51a"
integrity sha512-zilmvxAYD34IofBrwOliQn4z92UiDmt2c949DW4Gokf0vS0qk4YTfVCi/LmUBICThGygNANE3WfnRTpjCJGtDA==
dependencies:
chokidar "^3.4.3"
hardhat@^2.9.6:
version "2.9.6"
resolved "https://registry.yarnpkg.com/hardhat/-/hardhat-2.9.6.tgz#9b75d8efccdfc20bdea35ffb0fd4e6a3f3ecf3cf"
......@@ -13727,11 +13594,6 @@ js-yaml@4.1.0, js-yaml@^4.1.0:
dependencies:
argparse "^2.0.1"
jsbi@^3.1.4:
version "3.2.5"
resolved "https://registry.yarnpkg.com/jsbi/-/jsbi-3.2.5.tgz#b37bb90e0e5c2814c1c2a1bcd8c729888a2e37d6"
integrity sha512-aBE4n43IPvjaddScbvWRA2YlTzKEynHzu7MqOyTipdHucf/VxS63ViCjxYRg86M8Rxwbt/GfzHl1kKERkt45fQ==
jsbn@~0.1.0:
version "0.1.1"
resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
......@@ -20510,16 +20372,6 @@ timed-out@^4.0.0, timed-out@^4.0.1:
resolved "https://registry.yarnpkg.com/timed-out/-/timed-out-4.0.1.tgz#f32eacac5a175bea25d7fab565ab3ed8741ef56f"
integrity sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=
tiny-invariant@^1.1.0:
version "1.1.0"
resolved "https://registry.yarnpkg.com/tiny-invariant/-/tiny-invariant-1.1.0.tgz#634c5f8efdc27714b7f386c35e6760991d230875"
integrity sha512-ytxQvrb1cPc9WBEI/HSeYYoGD0kWnGEOR8RY6KomWLBVhqz0RgTwVO9dLrGz7dC+nN9llyI7OKAgRq8Vq4ZBSw==
tiny-warning@^1.0.3:
version "1.0.3"
resolved "https://registry.yarnpkg.com/tiny-warning/-/tiny-warning-1.0.3.tgz#94a30db453df4c643d0fd566060d60a875d84754"
integrity sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==
tinybench@^2.3.1:
version "2.3.1"
resolved "https://registry.yarnpkg.com/tinybench/-/tinybench-2.3.1.tgz#14f64e6b77d7ef0b1f6ab850c7a808c6760b414d"
......@@ -20596,11 +20448,6 @@ to-regex@^3.0.1, to-regex@^3.0.2:
regex-not "^1.0.2"
safe-regex "^1.1.0"
toformat@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/toformat/-/toformat-2.0.0.tgz#7a043fd2dfbe9021a4e36e508835ba32056739d8"
integrity sha512-03SWBVop6nU8bpyZCx7SodpYznbZF5R4ljwNLBcTQzKOD9xuihRo/psX58llS1BMFhhAI08H3luot5GoXJz2pQ==
toggle-selection@^1.0.6:
version "1.0.6"
resolved "https://registry.yarnpkg.com/toggle-selection/-/toggle-selection-1.0.6.tgz#6e45b1263f2017fa0acc7d89d78b15b8bf77da32"
......@@ -21288,15 +21135,6 @@ unist-util-visit-parents@^3.0.0:
"@types/unist" "^2.0.0"
unist-util-is "^4.0.0"
uniswap-v3-deploy-plugin@^0.1.0:
version "0.1.0"
resolved "https://registry.yarnpkg.com/uniswap-v3-deploy-plugin/-/uniswap-v3-deploy-plugin-0.1.0.tgz#dd1798106373c16108aa2b5a0ec3b176c5c51d43"
integrity sha512-goowszquDWierss0oCB91MoQY2W1ue1fixA7XrxPQbVU0pt7ZGUv2KvxqYtcjpey9AcJrveGJoGYvpSLxmkzaw==
dependencies:
"@uniswap/v3-core" "1.0.0"
"@uniswap/v3-periphery" "^1.0.1"
cli-table3 "^0.6.0"
universal-user-agent@^6.0.0:
version "6.0.0"
resolved "https://registry.yarnpkg.com/universal-user-agent/-/universal-user-agent-6.0.0.tgz#3381f8503b251c0d9cd21bc1de939ec9df5480ee"
......
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