BenchmarkTest.t.sol 8.27 KB
Newer Older
1 2
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
3

4
// Testing utilities
5 6
import { Test } from "forge-std/Test.sol";
import { Vm } from "forge-std/Vm.sol";
7 8 9
import "test/CommonTest.t.sol";
import { CrossDomainMessenger } from "src/universal/CrossDomainMessenger.sol";
import { ResourceMetering } from "src/L1/ResourceMetering.sol";
10 11

// Free function for setting the prevBaseFee param in the OptimismPortal.
12
function setPrevBaseFee(Vm _vm, address _op, uint128 _prevBaseFee) {
Mark Tyneway's avatar
Mark Tyneway committed
13
    _vm.store(address(_op), bytes32(uint256(1)), bytes32((block.number << 192) | _prevBaseFee));
14 15
}

16
contract SetPrevBaseFee_Test is Portal_Initializer {
Mark Tyneway's avatar
Mark Tyneway committed
17
    function test_setPrevBaseFee_succeeds() external {
18
        setPrevBaseFee(vm, address(op), 100 gwei);
19
        (uint128 prevBaseFee,, uint64 prevBlockNum) = op.params();
20 21 22 23 24
        assertEq(uint256(prevBaseFee), 100 gwei);
        assertEq(uint256(prevBlockNum), block.number);
    }
}

25 26 27 28 29 30
// Tests for obtaining pure gas cost estimates for commonly used functions.
// The objective with these benchmarks is to strip down the actual test functions
// so that they are nothing more than the call we want measure the gas cost of.
// In order to achieve this we make no assertions, and handle everything else in the setUp()
// function.
contract GasBenchMark_OptimismPortal is Portal_Initializer {
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
    // Reusable default values for a test withdrawal
    Types.WithdrawalTransaction _defaultTx;

    uint256 _proposedOutputIndex;
    uint256 _proposedBlockNumber;
    bytes[] _withdrawalProof;
    Types.OutputRootProof internal _outputRootProof;
    bytes32 _outputRoot;

    // Use a constructor to set the storage vars above, so as to minimize the number of ffi calls.
    constructor() {
        super.setUp();
        _defaultTx = Types.WithdrawalTransaction({
            nonce: 0,
            sender: alice,
            target: bob,
            value: 100,
            gasLimit: 100_000,
            data: hex""
        });

        // Get withdrawal proof data we can use for testing.
        bytes32 _storageRoot;
        bytes32 _stateRoot;
55
        (_stateRoot, _storageRoot, _outputRoot,, _withdrawalProof) = ffi.getProveWithdrawalTransactionInputs(_defaultTx);
56 57 58 59 60 61 62 63 64 65 66 67 68

        // Setup a dummy output root proof for reuse.
        _outputRootProof = Types.OutputRootProof({
            version: bytes32(uint256(0)),
            stateRoot: _stateRoot,
            messagePasserStorageRoot: _storageRoot,
            latestBlockhash: bytes32(uint256(0))
        });
        _proposedBlockNumber = oracle.nextBlockNumber();
        _proposedOutputIndex = oracle.nextOutputIndex();
    }

    // Get the system into a nice ready-to-use state.
69
    function setUp() public virtual override {
70 71 72 73 74 75
        // Configure the oracle to return the output root we've prepared.
        vm.warp(oracle.computeL2Timestamp(_proposedBlockNumber) + 1);
        vm.prank(oracle.PROPOSER());
        oracle.proposeL2Output(_outputRoot, _proposedBlockNumber, 0, 0);

        // Warp beyond the finalization period for the block we've proposed.
76
        vm.warp(oracle.getL2Output(_proposedOutputIndex).timestamp + oracle.FINALIZATION_PERIOD_SECONDS() + 1);
77

78 79 80 81
        // Fund the portal so that we can withdraw ETH.
        vm.deal(address(op), 0xFFFFFFFF);
    }

82 83
    function test_depositTransaction_benchmark() external {
        op.depositTransaction{ value: NON_ZERO_VALUE }(
84
            NON_ZERO_ADDRESS, ZERO_VALUE, NON_ZERO_GASLIMIT, false, NON_ZERO_DATA
85 86 87 88
        );
    }

    function test_depositTransaction_benchmark_1() external {
89
        setPrevBaseFee(vm, address(op), 1 gwei);
90
        op.depositTransaction{ value: NON_ZERO_VALUE }(
91
            NON_ZERO_ADDRESS, ZERO_VALUE, NON_ZERO_GASLIMIT, false, NON_ZERO_DATA
92 93
        );
    }
94 95

    function test_proveWithdrawalTransaction_benchmark() external {
96
        op.proveWithdrawalTransaction(_defaultTx, _proposedOutputIndex, _outputRootProof, _withdrawalProof);
97
    }
98 99 100
}

contract GasBenchMark_L1CrossDomainMessenger is Messenger_Initializer {
101
    function test_sendMessage_benchmark_0() external {
102
        vm.pauseGasMetering();
103
        setPrevBaseFee(vm, address(op), 1 gwei);
104
        // The amount of data typically sent during a bridge deposit.
105 106
        bytes memory data =
            hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
107
        vm.resumeGasMetering();
108 109 110
        L1Messenger.sendMessage(bob, data, uint32(100));
    }

111
    function test_sendMessage_benchmark_1() external {
112
        vm.pauseGasMetering();
113
        setPrevBaseFee(vm, address(op), 10 gwei);
114
        // The amount of data typically sent during a bridge deposit.
115 116
        bytes memory data =
            hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
117
        vm.resumeGasMetering();
118 119 120 121 122 123 124 125 126
        L1Messenger.sendMessage(bob, data, uint32(100));
    }
}

contract GasBenchMark_L1StandardBridge_Deposit is Bridge_Initializer {
    function setUp() public virtual override {
        super.setUp();
        deal(address(L1Token), alice, 100000, true);
        vm.startPrank(alice, alice);
127
        L1Token.approve(address(L1Bridge), type(uint256).max);
128 129 130
    }

    function test_depositETH_benchmark_0() external {
131
        vm.pauseGasMetering();
132
        setPrevBaseFee(vm, address(op), 1 gwei);
133
        vm.resumeGasMetering();
134 135 136 137
        L1Bridge.depositETH{ value: 500 }(50000, hex"");
    }

    function test_depositETH_benchmark_1() external {
138
        vm.pauseGasMetering();
139
        setPrevBaseFee(vm, address(op), 10 gwei);
140
        vm.resumeGasMetering();
141 142 143 144
        L1Bridge.depositETH{ value: 500 }(50000, hex"");
    }

    function test_depositERC20_benchmark_0() external {
145
        vm.pauseGasMetering();
146
        setPrevBaseFee(vm, address(op), 1 gwei);
147
        vm.resumeGasMetering();
148 149 150 151 152 153 154
        L1Bridge.bridgeERC20({
            _localToken: address(L1Token),
            _remoteToken: address(L2Token),
            _amount: 100,
            _minGasLimit: 100_000,
            _extraData: hex""
        });
155 156 157
    }

    function test_depositERC20_benchmark_1() external {
158
        vm.pauseGasMetering();
159
        setPrevBaseFee(vm, address(op), 10 gwei);
160
        vm.resumeGasMetering();
161 162 163 164 165 166 167
        L1Bridge.bridgeERC20({
            _localToken: address(L1Token),
            _remoteToken: address(L2Token),
            _amount: 100,
            _minGasLimit: 100_000,
            _extraData: hex""
        });
168 169 170 171 172 173 174 175 176 177
    }
}

contract GasBenchMark_L1StandardBridge_Finalize is Bridge_Initializer {
    function setUp() public virtual override {
        super.setUp();
        deal(address(L1Token), address(L1Bridge), 100, true);
        vm.mockCall(
            address(L1Bridge.messenger()),
            abi.encodeWithSelector(CrossDomainMessenger.xDomainMessageSender.selector),
178
            abi.encode(address(L1Bridge.OTHER_BRIDGE()))
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
        );
        vm.startPrank(address(L1Bridge.messenger()));
        vm.deal(address(L1Bridge.messenger()), 100);
    }

    function test_finalizeETHWithdrawal_benchmark() external {
        // TODO: Make this more accurate. It is underestimating the cost because it pranks
        // the call coming from the messenger, which bypasses the portal
        // and oracle.
        L1Bridge.finalizeETHWithdrawal{ value: 100 }(alice, alice, 100, hex"");
    }
}

contract GasBenchMark_L2OutputOracle is L2OutputOracle_Initializer {
    uint256 nextBlockNumber;

    function setUp() public override {
        super.setUp();
        nextBlockNumber = oracle.nextBlockNumber();
198 199
        warpToProposeTime(nextBlockNumber);
        vm.startPrank(proposer);
200 201
    }

202 203
    function test_proposeL2Output_benchmark() external {
        oracle.proposeL2Output(nonZeroHash, nextBlockNumber, 0, 0);
204 205
    }
}