From 0fae8c742427d6adeacb0fdbe37007a015124bb8 Mon Sep 17 00:00:00 2001 From: smtmfft Date: Mon, 28 Sep 2026 20:02:41 +0800 Subject: [PATCH 1/2] feat(protocol): rotate raiko2 artifacts to v0.9.0-rc1 --- .../layer1/verifiers/LibRisc0Constants.sol | 5 + .../layer1/verifiers/LibSP1Constants.sol | 9 + .../layer1/proposals/Proposal0026.action.md | 3 +- .../script/layer1/proposals/Proposal0026.md | 137 +++++++-- .../layer1/proposals/Proposal0026.s.sol | 269 +++++++++++++++++- .../test/layer1/proposals/Proposal0026.t.sol | 172 ++++++++++- .../layer1/proposals/Proposal0026Fork.t.sol | 152 +++++++++- 7 files changed, 701 insertions(+), 46 deletions(-) diff --git a/packages/protocol/contracts/layer1/verifiers/LibRisc0Constants.sol b/packages/protocol/contracts/layer1/verifiers/LibRisc0Constants.sol index 5aa152149c8..bc9679663b3 100644 --- a/packages/protocol/contracts/layer1/verifiers/LibRisc0Constants.sol +++ b/packages/protocol/contracts/layer1/verifiers/LibRisc0Constants.sol @@ -13,4 +13,9 @@ library LibRisc0Constants { 0xd6ab71c22201c23ef512b706f2e2d720f6da1b559fb76834aa9d4e35276f6e10; bytes32 internal constant V0_8_0_RC1_AGGREGATION_IMAGE_ID = 0xdd9b8abff96c409ae2418edfb51d893ea2bd10f4873a0226f17a6998c1afc1b7; + + bytes32 internal constant V0_9_0_RC1_PROPOSAL_IMAGE_ID = + 0x6016d9b774fdb7af1ac3194793039abb241ac869c856d15d2a0f5a5997e970ca; + bytes32 internal constant V0_9_0_RC1_AGGREGATION_IMAGE_ID = + 0xc7a55544d3a96ec3953a5bd2705c42056e27757fd6ac72ca9b972931870f8a2a; } diff --git a/packages/protocol/contracts/layer1/verifiers/LibSP1Constants.sol b/packages/protocol/contracts/layer1/verifiers/LibSP1Constants.sol index edb9a859570..46833b225f5 100644 --- a/packages/protocol/contracts/layer1/verifiers/LibSP1Constants.sol +++ b/packages/protocol/contracts/layer1/verifiers/LibSP1Constants.sol @@ -21,4 +21,13 @@ library LibSP1Constants { 0x0051ac1d9e8cfd4196e37f9cfefd08e9b0f7ce653bad4634cd1ee84b71ca3be6; bytes32 internal constant V0_8_0_RC1_AGGREGATION_PROGRAM_VKEY_HASH_BYTES = 0x28d60ecf233f50655c6ff39f6fd08e9b07be73296eb518d31a3dd09671ca3be6; + + bytes32 internal constant V0_9_0_RC1_PROPOSAL_PROGRAM_VKEY_BN254 = + 0x00609a2e8a5834a3675060fa8965315f3e978514aa49fe69f8f407e5d16b941f; + bytes32 internal constant V0_9_0_RC1_PROPOSAL_PROGRAM_VKEY_HASH_BYTES = + 0x304d1745160d28d96a0c1f51165315f374bc28a52927f9a771e80fcb516b941f; + bytes32 internal constant V0_9_0_RC1_AGGREGATION_PROGRAM_VKEY_BN254 = + 0x001047d2068ac6e9b57839a587b07a254ad724d69b69c10197c0d4d2660c2fba; + bytes32 internal constant V0_9_0_RC1_AGGREGATION_PROGRAM_VKEY_HASH_BYTES = + 0x0823e90322b1ba6d2f0734b07b07a25456b926b46da704062f81a9a4660c2fba; } diff --git a/packages/protocol/script/layer1/proposals/Proposal0026.action.md b/packages/protocol/script/layer1/proposals/Proposal0026.action.md index 70d7d8d2c47..eb88e4d0fcc 100644 --- a/packages/protocol/script/layer1/proposals/Proposal0026.action.md +++ b/packages/protocol/script/layer1/proposals/Proposal0026.action.md @@ -1,6 +1,5 @@ # Proposal0026 - - To (DAO Controller): `0x75Ba76403b13b26AD1beC70D6eE937314eeaCD0a` - Function: `Execute` - Value: `0` -- Calldata: `0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000200000000000000000000000006f21c543a4af5189ebdb0723827577e1ef57ef1f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000243659cfe6000000000000000000000000a18431d42c8df9778905fbea912acf1881b49d2e00000000000000000000000000000000000000000000000000000000` +- Calldata: `0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001500000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000036000000000000000000000000000000000000000000000000000000000000004400000000000000000000000000000000000000000000000000000000000000520000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000006e000000000000000000000000000000000000000000000000000000000000007c000000000000000000000000000000000000000000000000000000000000008a000000000000000000000000000000000000000000000000000000000000009800000000000000000000000000000000000000000000000000000000000000a600000000000000000000000000000000000000000000000000000000000000b400000000000000000000000000000000000000000000000000000000000000c200000000000000000000000000000000000000000000000000000000000000d000000000000000000000000000000000000000000000000000000000000000de00000000000000000000000000000000000000000000000000000000000000ec00000000000000000000000000000000000000000000000000000000000000fa0000000000000000000000000000000000000000000000000000000000000108000000000000000000000000000000000000000000000000000000000000011600000000000000000000000000000000000000000000000000000000000001240000000000000000000000000000000000000000000000000000000000000132000000000000000000000000000000000000000000000000000000000000014200000000000000000000000006f21c543a4af5189ebdb0723827577e1ef57ef1f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000243659cfe6000000000000000000000000a18431d42c8df9778905fbea912acf1881b49d2e00000000000000000000000000000000000000000000000000000000000000000000000000000000059daf31f571da48ab4e74ae12f64f907681cd8b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044ed761581d6ab71c22201c23ef512b706f2e2d720f6da1b559fb76834aa9d4e35276f6e10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000059daf31f571da48ab4e74ae12f64f907681cd8b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044ed761581dd9b8abff96c409ae2418edfb51d893ea2bd10f4873a0226f17a6998c1afc1b7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000059daf31f571da48ab4e74ae12f64f907681cd8b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044ed7615816016d9b774fdb7af1ac3194793039abb241ac869c856d15d2a0f5a5997e970ca000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000059daf31f571da48ab4e74ae12f64f907681cd8b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044ed761581c7a55544d3a96ec3953a5bd2705c42056e27757fd6ac72ca9b972931870f8a2a00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000073a0db393ef87ce781ac7957be10d6628432100f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044899e3b1a0025425c22e827507428a3d9c7b0f89635be5462f34bb6780563e3d6086be7c700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000073a0db393ef87ce781ac7957be10d6628432100f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044899e3b1a12a12e113a09d41d05147b387b0f89632df2a3174d2ed9e00ac7c7ac086be7c700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000073a0db393ef87ce781ac7957be10d6628432100f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044899e3b1a0051ac1d9e8cfd4196e37f9cfefd08e9b0f7ce653bad4634cd1ee84b71ca3be600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000073a0db393ef87ce781ac7957be10d6628432100f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044899e3b1a28d60ecf233f50655c6ff39f6fd08e9b07be73296eb518d31a3dd09671ca3be600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000073a0db393ef87ce781ac7957be10d6628432100f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044899e3b1a00609a2e8a5834a3675060fa8965315f3e978514aa49fe69f8f407e5d16b941f00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000073a0db393ef87ce781ac7957be10d6628432100f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044899e3b1a304d1745160d28d96a0c1f51165315f374bc28a52927f9a771e80fcb516b941f00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000073a0db393ef87ce781ac7957be10d6628432100f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044899e3b1a001047d2068ac6e9b57839a587b07a254ad724d69b69c10197c0d4d2660c2fba00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000073a0db393ef87ce781ac7957be10d6628432100f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044899e3b1a0823e90322b1ba6d2f0734b07b07a25456b926b46da704062f81a9a4660c2fba0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000ffa4a625ed9db32b70f99180fd00759fc3e92610000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000443a3430145f7da556f3b75dcc71465030e1b7274e82df9e9120c0b3eaf5bb76246a5140050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008d7c954960a36a7596d7ea4945ddf891967ca8a30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000443a3430143564b6a30089fcb3e2f69c19b22d23f84ce148387cd7a15f5c1df165b2ae58470000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008d7c954960a36a7596d7ea4945ddf891967ca8a30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000443a343014ae2c7b92b2a71238226cb624ecd1171b66bf943cc372314affca0e6748ccecdf0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffa4a625ed9db32b70f99180fd00759fc3e92610000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000443a34301451701ed3fbd0bfdcea24a2e47ce9e30c5448ca9e4ad9b48bd1530d4a9c022fe40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000008d7c954960a36a7596d7ea4945ddf891967ca8a30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000443a343014dc994928718200e16e0eb643486ea90e49970a897fd164e39b6ae11262b69ab90000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000008d7c954960a36a7596d7ea4945ddf891967ca8a30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000443a3430147aaf74aaa95cf967844819e5e4504f28308541c0504e6642a12a75a4669f66a300000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000041e79eb4f03abb5df8716b759528dc5d8f6a84ee0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000644ef36a56000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000009d3c595bff6ff7d2b2cbdecf94ad917eb2fcffd80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000644ef36a5600000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000` diff --git a/packages/protocol/script/layer1/proposals/Proposal0026.md b/packages/protocol/script/layer1/proposals/Proposal0026.md index 323a7044d78..1676138adf5 100644 --- a/packages/protocol/script/layer1/proposals/Proposal0026.md +++ b/packages/protocol/script/layer1/proposals/Proposal0026.md @@ -1,4 +1,4 @@ -# PROPOSAL-0026: Raise the Inbox Basefee Sharing Percentage to 100% +# PROPOSAL-0026: Raise Basefee Sharing to 100% and Rotate raiko2 to v0.9.0-rc1 ## Executive Summary @@ -10,10 +10,16 @@ nothing is retained by the L2 fee treasury, the Anchor contract configuration value and all five address immutables are the live ones; no storage is touched and no initializer runs. +The same atomic L1 batch rotates the active proving identifiers from raiko2 v0.8.0-rc1 to +[`v0.9.0-rc1`](https://github.com/taikoxyz/raiko2/releases/tag/v0.9.0-rc1): two RISC0 image IDs, +four SP1 program vkeys, and three SGX MRENCLAVE allowlist entries. It then deletes the active +v0.8.0-rc1 instance ID `2` from both SGX verifier registries. The already-disabled v0.6 values are +not touched. The SGX MRSIGNER and enclave attribute policies are unchanged, and this proposal does +not register replacement SGX instances. + The percentage is a constructor immutable of the inbox implementation (`MainnetInbox.sol`), so -changing it means deploying a new implementation and upgrading the proxy: one `upgradeTo`, executed -by the DAO controller, which owns the proxy. The proposal executes **1 L1 action** and has no L2 -leg. +changing it means deploying a new implementation and upgrading the proxy. That `upgradeTo` remains +action 0. The proposal executes **21 L1 actions** in total and has no L2 leg. ## Rationale @@ -87,12 +93,17 @@ which is what keeps proposing a real business rather than a free one. | Chain | Contract | Change | | ----- | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | L1 | Inbox proxy `0x6f21C543a4aF5189eBdb0723827577e1EF57ef1f` | implementation → `0xA18431d42C8dF9778905fBEa912aCF1881b49D2e` ([codediff](https://codediff.taiko.xyz/?addr=0x6f21C543a4aF5189eBdb0723827577e1EF57ef1f&newimpl=0xA18431d42C8dF9778905fBEa912aCF1881b49D2e&chainid=1)) | - -Not touched: the proof verifier, proposer checker, prover whitelist, signal service and bond token -(reproduced as immutables of the new implementation); every numeric parameter but the percentage; -the proxy's storage; ownership (no `transferOwnership`, `acceptOwnership` or initializer call); the -dormant Pacaya inbox `0x06a9Ab27c7e2255df1815E6CC0168d7755Feb19a`; every L2 contract; Hoodi and -every other network. +| L1 | RISC0 verifier `0x059dAF31F571da48Ab4e74Ae12F64f907681Cd8b` | disable the two v0.8.0-rc1 image IDs and enable the two v0.9.0-rc1 image IDs | +| L1 | SP1 verifier `0x73A0Db393ef87ce781ac7957bE10D6628432100F` | disable the four v0.8.0-rc1 program vkeys and enable the four v0.9.0-rc1 program vkeys | +| L1 | SGX attesters `0x0ffa…9261`, `0x8d7C…a8A3` | disable the three v0.8.0-rc1 MRENCLAVEs and enable the three v0.9.0-rc1 MRENCLAVEs | +| L1 | SGX verifiers `0x41e7…84Ee`, `0x9D3C…FFd8` | delete active instance ID `2`; replacement registration is a separate post-execution operation | + +The verifier implementations are not upgraded. The proposal changes only their trust mappings and +deletes the two named SGX registry entries; it does not change MRSIGNER trust, attribute policies, +verifier ownership, or verifier configuration. Also not touched: the inbox's proof verifier, +proposer checker, prover whitelist, signal service and bond token immutables; every numeric inbox +parameter but the percentage; the proxy's storage; ownership; the dormant Pacaya inbox +`0x06a9Ab27c7e2255df1815E6CC0168d7755Feb19a`; every L2 contract; Hoodi and every other network. `DevnetInbox` moves to 100 in the same PR so local and devnet deployments match mainnet. It is not in `MainnetInbox`'s dependency tree and no deployed contract reads it; its only consumer is @@ -100,6 +111,45 @@ in `MainnetInbox`'s dependency tree and no deployed contract reads it; its only ## What Changes +### raiko2 v0.9.0-rc1 release rotation + +The ZK identifiers below come from `guest-digests-summary.json` in the raiko2 v0.9.0-rc1 release. +The old column is the v0.8.0-rc1 set enabled by Proposal0021; the new column is enabled by this +proposal. + +| Role | v0.8.0-rc1 disabled | v0.9.0-rc1 enabled | +| ---- | -------------------- | ------------------ | +| RISC0 proposal image ID | `0xd6ab71c22201c23ef512b706f2e2d720f6da1b559fb76834aa9d4e35276f6e10` | `0x6016d9b774fdb7af1ac3194793039abb241ac869c856d15d2a0f5a5997e970ca` | +| RISC0 aggregation image ID | `0xdd9b8abff96c409ae2418edfb51d893ea2bd10f4873a0226f17a6998c1afc1b7` | `0xc7a55544d3a96ec3953a5bd2705c42056e27757fd6ac72ca9b972931870f8a2a` | +| SP1 proposal vkey BN254 | `0x0025425c22e827507428a3d9c7b0f89635be5462f34bb6780563e3d6086be7c7` | `0x00609a2e8a5834a3675060fa8965315f3e978514aa49fe69f8f407e5d16b941f` | +| SP1 proposal vkey hash bytes | `0x12a12e113a09d41d05147b387b0f89632df2a3174d2ed9e00ac7c7ac086be7c7` | `0x304d1745160d28d96a0c1f51165315f374bc28a52927f9a771e80fcb516b941f` | +| SP1 aggregation vkey BN254 | `0x0051ac1d9e8cfd4196e37f9cfefd08e9b0f7ce653bad4634cd1ee84b71ca3be6` | `0x001047d2068ac6e9b57839a587b07a254ad724d69b69c10197c0d4d2660c2fba` | +| SP1 aggregation vkey hash bytes | `0x28d60ecf233f50655c6ff39f6fd08e9b07be73296eb518d31a3dd09671ca3be6` | `0x0823e90322b1ba6d2f0734b07b07a25456b926b46da704062f81a9a4660c2fba` | + +The TEE values come from `tee-attestation-manifest-v0.9.0-rc1.json`: + +| Lane | v0.8.0-rc1 MRENCLAVE disabled | v0.9.0-rc1 MRENCLAVE enabled | +| ---- | ----------------------------- | ---------------------------- | +| SGX-geth | `0x5f7da556f3b75dcc71465030e1b7274e82df9e9120c0b3eaf5bb76246a514005` | `0x51701ed3fbd0bfdcea24a2e47ce9e30c5448ca9e4ad9b48bd1530d4a9c022fe4` | +| SGX-reth | `0x3564b6a30089fcb3e2f69c19b22d23f84ce148387cd7a15f5c1df165b2ae5847` | `0xdc994928718200e16e0eb643486ea90e49970a897fd164e39b6ae11262b69ab9` | +| SGX-reth EDMM | `0xae2c7b92b2a71238226cb624ecd1171b66bf943cc372314affca0e6748ccecdf` | `0x7aaf74aaa95cf967844819e5e4504f28308541c0504e6642a12a75a4669f66a3` | + +The release source commit is `c4825c5d7e2b51abff5cb1ff09bca86e9df1609e`. Its published runtime +image is +`us-docker.pkg.dev/evmchain/images/raiko2@sha256:41df977ef21c6fe3253e001211985b0d2ac78d8cd0190be78da3e7e4169f6659`. +The TEE images are pinned in the release manifest: + +- `raiko2-sgx@sha256:4798744ba980c3d6db0ea41712a5a81f9df25300be6d213b4df55d5a9c17d6f8` +- `raiko2-sgx` EDMM + `@sha256:7e358a426918982ad85e90309c3e1277997f1b6bfa775e2b46b62909838d42f9` +- `gaiko2-sgxgeth@sha256:870d49869f1017eb201b34abfb7fc39ec05038aa563441f01bdc679bf9566dc3` + +Both SGX verifiers have `nextInstanceId() == 3` at the pinned pre-execution state. IDs `0` and `1` +are empty and ID `2` is the active v0.8.0-rc1 registration. Actions 19 and 20 delete ID `2`. +After the proposal executes, each v0.9.0-rc1 provider must register separately; the next successful +registration is expected to receive instance ID `3`. That registration is deliberately not part of +this governance batch. + ### How the percentage reaches L2 blocks - `Inbox.propose` copies the `_basefeeSharingPctg` immutable into every `Proposal` and into the @@ -213,22 +263,39 @@ So the only behavioural change the new implementation ships is the percentage. N - **One unavoidable reorg at the switch.** Blocks preconfirmed under 75 but carried by the first proposal after execution are re-derived with 100 (same transactions). Executing the proposal right after a proposal lands, with the preconfer restart queued, bounds this to a few blocks. -- **Provers** (raiko2) take the value from the event and need no change. The bridge UI, the - relayer and the eventindexer are not affected. +- **Provers** take the basefee-sharing value from the event, so that part needs no code change. They + must nevertheless run the v0.9.0-rc1 artifacts after the verifier rotation. RISC0 and SP1 can + prove as soon as the batch executes; SGX providers additionally need the separate instance + registration described above. The bridge UI, relayer and eventindexer are not affected. - **Treasury income.** The Anchor contract `0x1670000000000000000000000000000000010001` stops receiving basefee; dashboards tracking it will show the step to zero. The ETH it has already accrued is untouched and stays withdrawable by the DAO through `Anchor.withdraw`. ## Action Order -### L1 — 1 action - -| # | Target | Call | -| --- | -------------------------------------------------------- | ----------------------------------- | -| 0 | Inbox proxy `0x6f21C543a4aF5189eBdb0723827577e1EF57ef1f` | `upgradeTo(MAINNET_INBOX_NEW_IMPL)` | +### L1 — 21 actions + +| # | Target | Call | +| - | ------ | ---- | +| 0 | Inbox proxy | `upgradeTo(MAINNET_INBOX_NEW_IMPL)` | +| 1 | RISC0 verifier | `setImageIdTrusted(V0_8_0_RC1_PROPOSAL_IMAGE_ID, false)` | +| 2 | RISC0 verifier | `setImageIdTrusted(V0_8_0_RC1_AGGREGATION_IMAGE_ID, false)` | +| 3 | RISC0 verifier | `setImageIdTrusted(V0_9_0_RC1_PROPOSAL_IMAGE_ID, true)` | +| 4 | RISC0 verifier | `setImageIdTrusted(V0_9_0_RC1_AGGREGATION_IMAGE_ID, true)` | +| 5–8 | SP1 verifier | disable the four v0.8.0-rc1 proposal/aggregation vkeys in the table above | +| 9–12 | SP1 verifier | enable the four v0.9.0-rc1 proposal/aggregation vkeys in the table above | +| 13 | SGX-geth attester | `setMrEnclave(OLD_SGXGETH_MR_ENCLAVE, false)` | +| 14 | SGX-reth attester | `setMrEnclave(OLD_SGXRETH_NON_EDMM_MR_ENCLAVE, false)` | +| 15 | SGX-reth attester | `setMrEnclave(OLD_SGXRETH_EDMM_MR_ENCLAVE, false)` | +| 16 | SGX-geth attester | `setMrEnclave(NEW_SGXGETH_MR_ENCLAVE, true)` | +| 17 | SGX-reth attester | `setMrEnclave(NEW_SGXRETH_NON_EDMM_MR_ENCLAVE, true)` | +| 18 | SGX-reth attester | `setMrEnclave(NEW_SGXRETH_EDMM_MR_ENCLAVE, true)` | +| 19 | SGX-geth verifier | `deleteInstances([2])` | +| 20 | SGX-reth verifier | `deleteInstances([2])` | No L2 leg: `buildL2Actions` is the `BuildProposal` default (empty), so `_buildAllActions` appends -no `sendMessage` and the batch is the one action above. +no `sendMessage`. The ordering keeps the existing Inbox upgrade as action 0 and performs the +release rotation after it in the same atomic controller execution. ## Deployment @@ -258,7 +325,8 @@ cast codesize 0x511e1E5D9b9E23958076ccF1dD0033237a8cE4f8 --rpc-url $L1_RPC # 1 The address was then written into `Proposal0026.MAINNET_INBOX_NEW_IMPL` and `DEPLOYED_INBOX_IMPL` in `test/layer1/proposals/Proposal0026.t.sol`; `Proposal0026.action.md` was generated with -`P=0026 pnpm proposal` and is pinned from then on by `test_actionFileMatchesTheBuiltCalldata`; the +`P=0026 pnpm proposal` after adding the release rotation, and is pinned from then on by +`test_actionFileMatchesTheBuiltCalldata`; the dry run `P=0026 pnpm proposal:dryrun:l1` reverted with `DryrunSucceeded()` as designed (`Controller.dryrun` is permissionless and always reverts, so the `--broadcast` in the script can never send anything); and the fork rehearsal executed the committed calldata against the deployed @@ -281,10 +349,13 @@ Deployed on 2026-09-12 by `0x56706f118e42ae069f20c5636141b844d1324ae1`, all in L Every commented value is the expected result. -The fork rehearsal defaults to L1 block **25,961,770**, after the implementation was deployed and -before the proxy upgrade, so it remains repeatable after execution. Use an archive-capable RPC. -Set `L1_FORK_BLOCK` to select another block in that interval; `--fork-block-number` does not select -the block of the fork created inside the test. +The fork rehearsal defaults to L1 block **26,075,649**, after the implementation deployment and +Proposal0021 execution but before Proposal0026. At that block all v0.8.0-rc1 identifiers are +trusted, all v0.9.0-rc1 identifiers are untrusted, `nextInstanceId()` is `3` on both SGX verifiers, +IDs `0` and `1` are empty, and ID `2` is active. The deployed `instances(uint256)` getter still has +the historical two-field `(address,uint64)` ABI. Use an archive-capable RPC. Set `L1_FORK_BLOCK` to +another block only if it has the same preconditions; `--fork-block-number` does not select the fork +created inside the test. ```bash export L1_RPC= @@ -350,10 +421,10 @@ rmdir "$PROPOSAL0026_VERIFY_DIR" # https://etherscan.io/address/0xA18431d42C8dF9778905fBEa912aCF1881b49D2e#code # The calldata: regenerate and diff, then the live dry run, then the historical fork rehearsal. The -# rehearsal executes the batch from the DAO controller at block 25,961,770 and asserts the proxy answers 100 -# with every other configuration field, the core state, the last and last-finalized proposal -# hashes, the forced-inclusion queue, the owner, the activation timestamp and the initializer -# version unchanged; the second test is the dry run itself. +# rehearsal executes the 21-action batch from the DAO controller at block 26,075,649. It asserts +# the inbox proxy answers 100 with its other state unchanged, rotates every RISC0/SP1/SGX trust +# value from v0.8.0-rc1 to v0.9.0-rc1, deletes SGX instance ID 2 on both verifiers, and leaves the +# batch with no L2 bridge message. The second test is the dry run itself. cd packages/protocol P=0026 pnpm proposal && git diff --exit-code script/layer1/proposals/Proposal0026.action.md P=0026 pnpm proposal:dryrun:l1 # reverts DryrunSucceeded() @@ -370,7 +441,17 @@ cast storage $INBOX 0 --rpc-url $L1_RPC # still 0x…03 # extraData starting with 0x64; blocks of earlier proposals keep 0x4b. ``` -Then restart the whitelisted preconfer nodes (see [Client rollout](#client-rollout)). +Then complete the release cutover: + +1. Confirm the two old RISC0 IDs return `false` and the two v0.9.0-rc1 IDs return `true`. +2. Confirm the four old SP1 vkeys return `false` and the four v0.9.0-rc1 vkeys return `true`. +3. Confirm the three old MRENCLAVEs return `false` and the three v0.9.0-rc1 MRENCLAVEs return + `true`. Confirm MRSIGNER trust and attribute policies are unchanged. +4. Confirm `instances(2)` returns a zero address on both SGX verifiers while `nextInstanceId()` + remains `3`. +5. Register the v0.9.0-rc1 SGX-geth and SGX-reth providers separately. Each next successful + registration is expected to receive ID `3`; record and read back the resulting transactions. +6. Restart the whitelisted preconfer nodes as described in [Client rollout](#client-rollout). ## Security Contacts diff --git a/packages/protocol/script/layer1/proposals/Proposal0026.s.sol b/packages/protocol/script/layer1/proposals/Proposal0026.s.sol index c64a86e369b..b7062af2ef1 100644 --- a/packages/protocol/script/layer1/proposals/Proposal0026.s.sol +++ b/packages/protocol/script/layer1/proposals/Proposal0026.s.sol @@ -3,6 +3,10 @@ pragma solidity ^0.8.24; import { BuildProposal } from "../governance/BuildProposal.sol"; import { LibL1Addrs as L1 } from "src/layer1/mainnet/LibL1Addrs.sol"; +import { LibRisc0Constants } from "src/layer1/verifiers/LibRisc0Constants.sol"; +import { LibSP1Constants } from "src/layer1/verifiers/LibSP1Constants.sol"; +import { Risc0Verifier } from "src/layer1/verifiers/Risc0Verifier.sol"; +import { SP1Verifier } from "src/layer1/verifiers/SP1Verifier.sol"; import { Controller } from "src/shared/governance/Controller.sol"; // To print the proposal action data: `P=0026 pnpm proposal` @@ -12,27 +16,53 @@ contract Proposal0026 is BuildProposal { /// @dev The `MainnetInbox` implementation the inbox proxy upgrades to: the live configuration /// with `basefeeSharingPctg` raised from 75 to 100. Deployed by `DeployInboxUpgradeL1` on /// Ethereum mainnet. - /// https://codediff.taiko.xyz/?addr=0x6f21C543a4aF5189eBdb0723827577e1EF57ef1f&newimpl=0xA18431d42C8dF9778905fBEa912aCF1881b49D2e&chainid=1 + /// See `Proposal0026.md` for the deployed implementation's codediff. address public constant MAINNET_INBOX_NEW_IMPL = 0xA18431d42C8dF9778905fBEa912aCF1881b49D2e; + // Current raiko2 v0.8.0-rc1 TEE MRENCLAVE values trusted on the attester proxies. + bytes32 public constant OLD_SGXGETH_MR_ENCLAVE = + 0x5f7da556f3b75dcc71465030e1b7274e82df9e9120c0b3eaf5bb76246a514005; + bytes32 public constant OLD_SGXRETH_NON_EDMM_MR_ENCLAVE = + 0x3564b6a30089fcb3e2f69c19b22d23f84ce148387cd7a15f5c1df165b2ae5847; + bytes32 public constant OLD_SGXRETH_EDMM_MR_ENCLAVE = + 0xae2c7b92b2a71238226cb624ecd1171b66bf943cc372314affca0e6748ccecdf; + + // New raiko2 v0.9.0-rc1 TEE MRENCLAVE values. + // Source: https://github.com/taikoxyz/raiko2/releases/tag/v0.9.0-rc1 + bytes32 public constant NEW_SGXGETH_MR_ENCLAVE = + 0x51701ed3fbd0bfdcea24a2e47ce9e30c5448ca9e4ad9b48bd1530d4a9c022fe4; + bytes32 public constant NEW_SGXRETH_NON_EDMM_MR_ENCLAVE = + 0xdc994928718200e16e0eb643486ea90e49970a897fd164e39b6ae11262b69ab9; + bytes32 public constant NEW_SGXRETH_EDMM_MR_ENCLAVE = + 0x7aaf74aaa95cf967844819e5e4504f28308541c0504e6642a12a75a4669f66a3; + error ImplementationNotDeployed(); + error Risc0ImageIdNotSet(); + error Risc0ImageIdNotRotated(); + error SP1ProgramVKeyNotSet(); + error SP1ProgramVKeyNotRotated(); + error SgxMrEnclaveNotSet(); + error SgxMrEnclaveNotRotated(); function buildL1Actions() internal pure override returns (Controller.Action[] memory) { return buildL1Actions(MAINNET_INBOX_NEW_IMPL); } /// @dev Encodes the L1 leg against an injectable implementation so tests can assert the - /// encoding while the constant above is still a placeholder. + /// complete batch independently of the deployed inbox implementation address. /// @param _inboxImpl The implementation the inbox proxy upgrades to. - /// @return actions The single L1 action. + /// @return actions The complete 21-action L1 batch. function buildL1Actions(address _inboxImpl) internal pure returns (Controller.Action[] memory actions) { require(_inboxImpl != address(0), ImplementationNotDeployed()); + _checkRisc0Constants(); + _checkSP1Constants(); + _checkSgxConstants(); - actions = new Controller.Action[](1); + actions = new Controller.Action[](21); // 0: Upgrade the inbox to the implementation that pays the whole basefee to the coinbase. // Immutables only: the new implementation carries the live proof verifier, proposer @@ -42,5 +72,236 @@ contract Proposal0026 is BuildProposal { // Proposals already made keep the percentage they were proposed with; the first propose // after execution carries 100. actions[0] = buildUpgradeAction(L1.INBOX, _inboxImpl); + + // 1-4: Rotate the trusted RISC0 image IDs to raiko2 v0.9.0-rc1. + actions[1] = Controller.Action({ + target: L1.RISC0_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + Risc0Verifier.setImageIdTrusted, + (LibRisc0Constants.V0_8_0_RC1_PROPOSAL_IMAGE_ID, false) + ) + }); + actions[2] = Controller.Action({ + target: L1.RISC0_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + Risc0Verifier.setImageIdTrusted, + (LibRisc0Constants.V0_8_0_RC1_AGGREGATION_IMAGE_ID, false) + ) + }); + actions[3] = Controller.Action({ + target: L1.RISC0_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + Risc0Verifier.setImageIdTrusted, + (LibRisc0Constants.V0_9_0_RC1_PROPOSAL_IMAGE_ID, true) + ) + }); + actions[4] = Controller.Action({ + target: L1.RISC0_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + Risc0Verifier.setImageIdTrusted, + (LibRisc0Constants.V0_9_0_RC1_AGGREGATION_IMAGE_ID, true) + ) + }); + + // 5-12: Rotate the trusted SP1 program verification keys the same way. + actions[5] = Controller.Action({ + target: L1.SP1_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + SP1Verifier.setProgramTrusted, + (LibSP1Constants.V0_8_0_RC1_PROPOSAL_PROGRAM_VKEY_BN254, false) + ) + }); + actions[6] = Controller.Action({ + target: L1.SP1_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + SP1Verifier.setProgramTrusted, + (LibSP1Constants.V0_8_0_RC1_PROPOSAL_PROGRAM_VKEY_HASH_BYTES, false) + ) + }); + actions[7] = Controller.Action({ + target: L1.SP1_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + SP1Verifier.setProgramTrusted, + (LibSP1Constants.V0_8_0_RC1_AGGREGATION_PROGRAM_VKEY_BN254, false) + ) + }); + actions[8] = Controller.Action({ + target: L1.SP1_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + SP1Verifier.setProgramTrusted, + (LibSP1Constants.V0_8_0_RC1_AGGREGATION_PROGRAM_VKEY_HASH_BYTES, false) + ) + }); + actions[9] = Controller.Action({ + target: L1.SP1_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + SP1Verifier.setProgramTrusted, + (LibSP1Constants.V0_9_0_RC1_PROPOSAL_PROGRAM_VKEY_BN254, true) + ) + }); + actions[10] = Controller.Action({ + target: L1.SP1_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + SP1Verifier.setProgramTrusted, + (LibSP1Constants.V0_9_0_RC1_PROPOSAL_PROGRAM_VKEY_HASH_BYTES, true) + ) + }); + actions[11] = Controller.Action({ + target: L1.SP1_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + SP1Verifier.setProgramTrusted, + (LibSP1Constants.V0_9_0_RC1_AGGREGATION_PROGRAM_VKEY_BN254, true) + ) + }); + actions[12] = Controller.Action({ + target: L1.SP1_RETH_VERIFIER, + value: 0, + data: abi.encodeCall( + SP1Verifier.setProgramTrusted, + (LibSP1Constants.V0_9_0_RC1_AGGREGATION_PROGRAM_VKEY_HASH_BYTES, true) + ) + }); + + // 13-18: Rotate the trusted SGX MRENCLAVE values on the reused attester proxies. MRSIGNER + // and the deployed attribute policy remain unchanged. + actions[13] = Controller.Action({ + target: L1.SGXGETH_ATTESTER, + value: 0, + data: abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (OLD_SGXGETH_MR_ENCLAVE, false) + ) + }); + actions[14] = Controller.Action({ + target: L1.SGXRETH_ATTESTER, + value: 0, + data: abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (OLD_SGXRETH_NON_EDMM_MR_ENCLAVE, false) + ) + }); + actions[15] = Controller.Action({ + target: L1.SGXRETH_ATTESTER, + value: 0, + data: abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (OLD_SGXRETH_EDMM_MR_ENCLAVE, false) + ) + }); + actions[16] = Controller.Action({ + target: L1.SGXGETH_ATTESTER, + value: 0, + data: abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (NEW_SGXGETH_MR_ENCLAVE, true) + ) + }); + actions[17] = Controller.Action({ + target: L1.SGXRETH_ATTESTER, + value: 0, + data: abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (NEW_SGXRETH_NON_EDMM_MR_ENCLAVE, true) + ) + }); + actions[18] = Controller.Action({ + target: L1.SGXRETH_ATTESTER, + value: 0, + data: abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (NEW_SGXRETH_EDMM_MR_ENCLAVE, true) + ) + }); + + // 19-20: Delete the currently registered raiko2 v0.8.0-rc1 SGX instances. Registering + // fresh v0.9.0-rc1 instances is a separate post-execution operation. + uint256[] memory instanceIds = new uint256[](1); + instanceIds[0] = 2; + actions[19] = Controller.Action({ + target: L1.SGXGETH_VERIFIER, + value: 0, + data: abi.encodeCall(IProposal0026SgxVerifier.deleteInstances, (instanceIds)) + }); + actions[20] = Controller.Action({ + target: L1.SGXRETH_VERIFIER, + value: 0, + data: abi.encodeCall(IProposal0026SgxVerifier.deleteInstances, (instanceIds)) + }); + } + + function _checkRisc0Constants() private pure { + require( + LibRisc0Constants.V0_8_0_RC1_PROPOSAL_IMAGE_ID != bytes32(0) + && LibRisc0Constants.V0_8_0_RC1_AGGREGATION_IMAGE_ID != bytes32(0) + && LibRisc0Constants.V0_9_0_RC1_PROPOSAL_IMAGE_ID != bytes32(0) + && LibRisc0Constants.V0_9_0_RC1_AGGREGATION_IMAGE_ID != bytes32(0), + Risc0ImageIdNotSet() + ); + require( + LibRisc0Constants.V0_8_0_RC1_PROPOSAL_IMAGE_ID + != LibRisc0Constants.V0_9_0_RC1_PROPOSAL_IMAGE_ID + && LibRisc0Constants.V0_8_0_RC1_AGGREGATION_IMAGE_ID + != LibRisc0Constants.V0_9_0_RC1_AGGREGATION_IMAGE_ID, + Risc0ImageIdNotRotated() + ); } + + function _checkSP1Constants() private pure { + require( + LibSP1Constants.V0_8_0_RC1_PROPOSAL_PROGRAM_VKEY_BN254 != bytes32(0) + && LibSP1Constants.V0_8_0_RC1_PROPOSAL_PROGRAM_VKEY_HASH_BYTES != bytes32(0) + && LibSP1Constants.V0_8_0_RC1_AGGREGATION_PROGRAM_VKEY_BN254 != bytes32(0) + && LibSP1Constants.V0_8_0_RC1_AGGREGATION_PROGRAM_VKEY_HASH_BYTES != bytes32(0) + && LibSP1Constants.V0_9_0_RC1_PROPOSAL_PROGRAM_VKEY_BN254 != bytes32(0) + && LibSP1Constants.V0_9_0_RC1_PROPOSAL_PROGRAM_VKEY_HASH_BYTES != bytes32(0) + && LibSP1Constants.V0_9_0_RC1_AGGREGATION_PROGRAM_VKEY_BN254 != bytes32(0) + && LibSP1Constants.V0_9_0_RC1_AGGREGATION_PROGRAM_VKEY_HASH_BYTES != bytes32(0), + SP1ProgramVKeyNotSet() + ); + require( + LibSP1Constants.V0_8_0_RC1_PROPOSAL_PROGRAM_VKEY_BN254 + != LibSP1Constants.V0_9_0_RC1_PROPOSAL_PROGRAM_VKEY_BN254 + && LibSP1Constants.V0_8_0_RC1_PROPOSAL_PROGRAM_VKEY_HASH_BYTES + != LibSP1Constants.V0_9_0_RC1_PROPOSAL_PROGRAM_VKEY_HASH_BYTES + && LibSP1Constants.V0_8_0_RC1_AGGREGATION_PROGRAM_VKEY_BN254 + != LibSP1Constants.V0_9_0_RC1_AGGREGATION_PROGRAM_VKEY_BN254 + && LibSP1Constants.V0_8_0_RC1_AGGREGATION_PROGRAM_VKEY_HASH_BYTES + != LibSP1Constants.V0_9_0_RC1_AGGREGATION_PROGRAM_VKEY_HASH_BYTES, + SP1ProgramVKeyNotRotated() + ); + } + + function _checkSgxConstants() private pure { + require( + OLD_SGXGETH_MR_ENCLAVE != bytes32(0) && OLD_SGXRETH_NON_EDMM_MR_ENCLAVE != bytes32(0) + && OLD_SGXRETH_EDMM_MR_ENCLAVE != bytes32(0) && NEW_SGXGETH_MR_ENCLAVE != bytes32(0) + && NEW_SGXRETH_NON_EDMM_MR_ENCLAVE != bytes32(0) + && NEW_SGXRETH_EDMM_MR_ENCLAVE != bytes32(0), + SgxMrEnclaveNotSet() + ); + require( + OLD_SGXGETH_MR_ENCLAVE != NEW_SGXGETH_MR_ENCLAVE + && OLD_SGXRETH_NON_EDMM_MR_ENCLAVE != NEW_SGXRETH_NON_EDMM_MR_ENCLAVE + && OLD_SGXRETH_EDMM_MR_ENCLAVE != NEW_SGXRETH_EDMM_MR_ENCLAVE, + SgxMrEnclaveNotRotated() + ); + } +} + +interface IProposal0026Attestation { + /// @notice Updates whether an SGX application MRENCLAVE is trusted for attestation. + /// @param _mrEnclave The SGX application enclave measurement to update. + /// @param _trusted True to trust the measurement, false to untrust it. + function setMrEnclave(bytes32 _mrEnclave, bool _trusted) external; +} + +interface IProposal0026SgxVerifier { + /// @notice Deletes SGX verifier instances by instance ID. + /// @param _ids The SGX instance IDs to delete. + function deleteInstances(uint256[] calldata _ids) external; } diff --git a/packages/protocol/test/layer1/proposals/Proposal0026.t.sol b/packages/protocol/test/layer1/proposals/Proposal0026.t.sol index 5c8518f8f24..7b0d0acbd2a 100644 --- a/packages/protocol/test/layer1/proposals/Proposal0026.t.sol +++ b/packages/protocol/test/layer1/proposals/Proposal0026.t.sol @@ -8,6 +8,8 @@ import { Proposal0026 } from "script/layer1/proposals/Proposal0026.s.sol"; import { IInbox } from "src/layer1/core/iface/IInbox.sol"; import { LibL1Addrs as L1 } from "src/layer1/mainnet/LibL1Addrs.sol"; import { MainnetInbox } from "src/layer1/mainnet/MainnetInbox.sol"; +import { Risc0Verifier } from "src/layer1/verifiers/Risc0Verifier.sol"; +import { SP1Verifier } from "src/layer1/verifiers/SP1Verifier.sol"; import { Controller } from "src/shared/governance/Controller.sol"; /// @custom:security-contact security@taiko.xyz @@ -18,17 +20,158 @@ contract Proposal0026Test is Test { /// `Proposal0026`, so an edit to the constant there cannot be mirrored here. address internal constant DEPLOYED_INBOX_IMPL = 0xA18431d42C8dF9778905fBEa912aCF1881b49D2e; + address internal constant RISC0_RETH_VERIFIER = 0x059dAF31F571da48Ab4e74Ae12F64f907681Cd8b; + address internal constant SP1_RETH_VERIFIER = 0x73A0Db393ef87ce781ac7957bE10D6628432100F; + address internal constant SGXGETH_VERIFIER = 0x41e79EB4F03aBB5DF8716B759528dc5d8f6a84Ee; + address internal constant SGXRETH_VERIFIER = 0x9D3C595BFf6Ff7D2b2CbdEcF94aD917eB2fCFFd8; + address internal constant SGXGETH_ATTESTER = 0x0ffa4A625ED9DB32B70F99180FD00759fc3e9261; + address internal constant SGXRETH_ATTESTER = 0x8d7C954960a36a7596d7eA4945dDf891967ca8A3; + + bytes32 internal constant OLD_RISC0_PROPOSAL_IMAGE_ID = + 0xd6ab71c22201c23ef512b706f2e2d720f6da1b559fb76834aa9d4e35276f6e10; + bytes32 internal constant OLD_RISC0_AGGREGATION_IMAGE_ID = + 0xdd9b8abff96c409ae2418edfb51d893ea2bd10f4873a0226f17a6998c1afc1b7; + bytes32 internal constant NEW_RISC0_PROPOSAL_IMAGE_ID = + 0x6016d9b774fdb7af1ac3194793039abb241ac869c856d15d2a0f5a5997e970ca; + bytes32 internal constant NEW_RISC0_AGGREGATION_IMAGE_ID = + 0xc7a55544d3a96ec3953a5bd2705c42056e27757fd6ac72ca9b972931870f8a2a; + + bytes32 internal constant OLD_SP1_PROPOSAL_VKEY_BN254 = + 0x0025425c22e827507428a3d9c7b0f89635be5462f34bb6780563e3d6086be7c7; + bytes32 internal constant OLD_SP1_PROPOSAL_VKEY_HASH_BYTES = + 0x12a12e113a09d41d05147b387b0f89632df2a3174d2ed9e00ac7c7ac086be7c7; + bytes32 internal constant OLD_SP1_AGGREGATION_VKEY_BN254 = + 0x0051ac1d9e8cfd4196e37f9cfefd08e9b0f7ce653bad4634cd1ee84b71ca3be6; + bytes32 internal constant OLD_SP1_AGGREGATION_VKEY_HASH_BYTES = + 0x28d60ecf233f50655c6ff39f6fd08e9b07be73296eb518d31a3dd09671ca3be6; + bytes32 internal constant NEW_SP1_PROPOSAL_VKEY_BN254 = + 0x00609a2e8a5834a3675060fa8965315f3e978514aa49fe69f8f407e5d16b941f; + bytes32 internal constant NEW_SP1_PROPOSAL_VKEY_HASH_BYTES = + 0x304d1745160d28d96a0c1f51165315f374bc28a52927f9a771e80fcb516b941f; + bytes32 internal constant NEW_SP1_AGGREGATION_VKEY_BN254 = + 0x001047d2068ac6e9b57839a587b07a254ad724d69b69c10197c0d4d2660c2fba; + bytes32 internal constant NEW_SP1_AGGREGATION_VKEY_HASH_BYTES = + 0x0823e90322b1ba6d2f0734b07b07a25456b926b46da704062f81a9a4660c2fba; + + bytes32 internal constant OLD_SGXGETH_MR_ENCLAVE = + 0x5f7da556f3b75dcc71465030e1b7274e82df9e9120c0b3eaf5bb76246a514005; + bytes32 internal constant OLD_SGXRETH_NON_EDMM_MR_ENCLAVE = + 0x3564b6a30089fcb3e2f69c19b22d23f84ce148387cd7a15f5c1df165b2ae5847; + bytes32 internal constant OLD_SGXRETH_EDMM_MR_ENCLAVE = + 0xae2c7b92b2a71238226cb624ecd1171b66bf943cc372314affca0e6748ccecdf; + bytes32 internal constant NEW_SGXGETH_MR_ENCLAVE = + 0x51701ed3fbd0bfdcea24a2e47ce9e30c5448ca9e4ad9b48bd1530d4a9c022fe4; + bytes32 internal constant NEW_SGXRETH_NON_EDMM_MR_ENCLAVE = + 0xdc994928718200e16e0eb643486ea90e49970a897fd164e39b6ae11262b69ab9; + bytes32 internal constant NEW_SGXRETH_EDMM_MR_ENCLAVE = + 0x7aaf74aaa95cf967844819e5e4504f28308541c0504e6642a12a75a4669f66a3; + Proposal0026Harness internal proposal; function setUp() external { proposal = new Proposal0026Harness(); } - function test_buildL1Actions_EncodesTheInboxUpgrade() external view { + function test_buildL1Actions_EncodesInboxUpgradeAndVerifierRotation() external view { Controller.Action[] memory actions = proposal.exposedBuildL1Actions(INBOX_NEW_IMPL); - assertEq(actions.length, 1); - _assertUpgrades(actions[0], L1.INBOX, INBOX_NEW_IMPL); + assertEq(actions.length, 21); + uint256 cursor; + + _assertUpgrades(actions[cursor++], L1.INBOX, INBOX_NEW_IMPL); + + _assertCall( + actions[cursor++], + RISC0_RETH_VERIFIER, + abi.encodeCall(Risc0Verifier.setImageIdTrusted, (OLD_RISC0_PROPOSAL_IMAGE_ID, false)) + ); + _assertCall( + actions[cursor++], + RISC0_RETH_VERIFIER, + abi.encodeCall(Risc0Verifier.setImageIdTrusted, (OLD_RISC0_AGGREGATION_IMAGE_ID, false)) + ); + _assertCall( + actions[cursor++], + RISC0_RETH_VERIFIER, + abi.encodeCall(Risc0Verifier.setImageIdTrusted, (NEW_RISC0_PROPOSAL_IMAGE_ID, true)) + ); + _assertCall( + actions[cursor++], + RISC0_RETH_VERIFIER, + abi.encodeCall(Risc0Verifier.setImageIdTrusted, (NEW_RISC0_AGGREGATION_IMAGE_ID, true)) + ); + + bytes32[8] memory sp1VKeys = [ + OLD_SP1_PROPOSAL_VKEY_BN254, + OLD_SP1_PROPOSAL_VKEY_HASH_BYTES, + OLD_SP1_AGGREGATION_VKEY_BN254, + OLD_SP1_AGGREGATION_VKEY_HASH_BYTES, + NEW_SP1_PROPOSAL_VKEY_BN254, + NEW_SP1_PROPOSAL_VKEY_HASH_BYTES, + NEW_SP1_AGGREGATION_VKEY_BN254, + NEW_SP1_AGGREGATION_VKEY_HASH_BYTES + ]; + for (uint256 i; i < sp1VKeys.length; ++i) { + _assertCall( + actions[cursor++], + SP1_RETH_VERIFIER, + abi.encodeCall(SP1Verifier.setProgramTrusted, (sp1VKeys[i], i >= 4)) + ); + } + + _assertCall( + actions[cursor++], + SGXGETH_ATTESTER, + abi.encodeCall(IProposal0026Attestation.setMrEnclave, (OLD_SGXGETH_MR_ENCLAVE, false)) + ); + _assertCall( + actions[cursor++], + SGXRETH_ATTESTER, + abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (OLD_SGXRETH_NON_EDMM_MR_ENCLAVE, false) + ) + ); + _assertCall( + actions[cursor++], + SGXRETH_ATTESTER, + abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (OLD_SGXRETH_EDMM_MR_ENCLAVE, false) + ) + ); + _assertCall( + actions[cursor++], + SGXGETH_ATTESTER, + abi.encodeCall(IProposal0026Attestation.setMrEnclave, (NEW_SGXGETH_MR_ENCLAVE, true)) + ); + _assertCall( + actions[cursor++], + SGXRETH_ATTESTER, + abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (NEW_SGXRETH_NON_EDMM_MR_ENCLAVE, true) + ) + ); + _assertCall( + actions[cursor++], + SGXRETH_ATTESTER, + abi.encodeCall( + IProposal0026Attestation.setMrEnclave, (NEW_SGXRETH_EDMM_MR_ENCLAVE, true) + ) + ); + + uint256[] memory instanceIds = new uint256[](1); + instanceIds[0] = 2; + _assertCall( + actions[cursor++], + SGXGETH_VERIFIER, + abi.encodeCall(IProposal0026SgxVerifier.deleteInstances, (instanceIds)) + ); + _assertCall( + actions[cursor++], + SGXRETH_VERIFIER, + abi.encodeCall(IProposal0026SgxVerifier.deleteInstances, (instanceIds)) + ); + + assertEq(cursor, actions.length); } function test_buildL1Actions_RevertsWhileTheImplementationIsMissing() external { @@ -51,7 +194,7 @@ contract Proposal0026Test is Test { /// rather than a read of `Proposal0026`, so an edit to that constant cannot be mirrored here. function test_buildL1Actions_UsesDeployedImplementation() external view { Controller.Action[] memory actions = proposal.exposedBuildAllActions(); - assertEq(actions.length, 1, "an L1-only proposal appends no bridge message"); + assertEq(actions.length, 21, "an L1-only proposal appends no bridge message"); _assertUpgrades(actions[0], L1.INBOX, DEPLOYED_INBOX_IMPL); } @@ -130,4 +273,25 @@ contract Proposal0026Test is Test { assertEq(_action.value, 0); assertEq(_action.data, abi.encodeCall(UUPSUpgradeable.upgradeTo, (_newImpl))); } + + function _assertCall( + Controller.Action memory _action, + address _target, + bytes memory _data + ) + internal + pure + { + assertEq(_action.target, _target); + assertEq(_action.value, 0); + assertEq(_action.data, _data); + } +} + +interface IProposal0026Attestation { + function setMrEnclave(bytes32 _mrEnclave, bool _trusted) external; +} + +interface IProposal0026SgxVerifier { + function deleteInstances(uint256[] calldata _ids) external; } diff --git a/packages/protocol/test/layer1/proposals/Proposal0026Fork.t.sol b/packages/protocol/test/layer1/proposals/Proposal0026Fork.t.sol index d5afb7317a8..a8ada0e5874 100644 --- a/packages/protocol/test/layer1/proposals/Proposal0026Fork.t.sol +++ b/packages/protocol/test/layer1/proposals/Proposal0026Fork.t.sol @@ -7,6 +7,8 @@ import { IForcedInclusionStore } from "src/layer1/core/iface/IForcedInclusionSto import { IInbox } from "src/layer1/core/iface/IInbox.sol"; import { Inbox } from "src/layer1/core/impl/Inbox.sol"; import { LibL1Addrs as L1 } from "src/layer1/mainnet/LibL1Addrs.sol"; +import { Risc0Verifier } from "src/layer1/verifiers/Risc0Verifier.sol"; +import { SP1Verifier } from "src/layer1/verifiers/SP1Verifier.sol"; import { Controller } from "src/shared/governance/Controller.sol"; /// @notice Rehearses the Proposal0026 upgrade against a historical mainnet fork. @@ -14,7 +16,8 @@ import { Controller } from "src/shared/governance/Controller.sol"; /// /// L1_FORK_URL= FOUNDRY_PROFILE=layer1 forge test --match-contract Proposal0026ForkTest -vv /// -/// Defaults to block 25,961,770, after implementation deployment and before the proxy upgrade. +/// Defaults to block 26,075,649, after Proposal0021 and the new inbox implementation deployment, +/// but before Proposal0026. /// Set `L1_FORK_BLOCK` to use another pre-upgrade block with an archive RPC. `--fork-block-number` /// does not select the block of the fork this test creates. /// @@ -54,8 +57,47 @@ contract Proposal0026ForkTest is Test { /// rehearse current -> current instead of the intended transition. address private constant _LIVE_INBOX_IMPL = 0x5253D4C91e80b880DdB54B78E74082Abe066F6b9; - /// @dev Recorded pre-upgrade state after the new implementation's deployment at block 25,961,745. - uint256 private constant _DEFAULT_L1_FORK_BLOCK = 25_961_770; + /// @dev Recorded post-Proposal0021, pre-Proposal0026 mainnet state. + uint256 private constant _DEFAULT_L1_FORK_BLOCK = 26_075_649; + + bytes32 private constant _OLD_RISC0_PROPOSAL_IMAGE_ID = + 0xd6ab71c22201c23ef512b706f2e2d720f6da1b559fb76834aa9d4e35276f6e10; + bytes32 private constant _OLD_RISC0_AGGREGATION_IMAGE_ID = + 0xdd9b8abff96c409ae2418edfb51d893ea2bd10f4873a0226f17a6998c1afc1b7; + bytes32 private constant _NEW_RISC0_PROPOSAL_IMAGE_ID = + 0x6016d9b774fdb7af1ac3194793039abb241ac869c856d15d2a0f5a5997e970ca; + bytes32 private constant _NEW_RISC0_AGGREGATION_IMAGE_ID = + 0xc7a55544d3a96ec3953a5bd2705c42056e27757fd6ac72ca9b972931870f8a2a; + + bytes32 private constant _OLD_SP1_PROPOSAL_VKEY_BN254 = + 0x0025425c22e827507428a3d9c7b0f89635be5462f34bb6780563e3d6086be7c7; + bytes32 private constant _OLD_SP1_PROPOSAL_VKEY_HASH_BYTES = + 0x12a12e113a09d41d05147b387b0f89632df2a3174d2ed9e00ac7c7ac086be7c7; + bytes32 private constant _OLD_SP1_AGGREGATION_VKEY_BN254 = + 0x0051ac1d9e8cfd4196e37f9cfefd08e9b0f7ce653bad4634cd1ee84b71ca3be6; + bytes32 private constant _OLD_SP1_AGGREGATION_VKEY_HASH_BYTES = + 0x28d60ecf233f50655c6ff39f6fd08e9b07be73296eb518d31a3dd09671ca3be6; + bytes32 private constant _NEW_SP1_PROPOSAL_VKEY_BN254 = + 0x00609a2e8a5834a3675060fa8965315f3e978514aa49fe69f8f407e5d16b941f; + bytes32 private constant _NEW_SP1_PROPOSAL_VKEY_HASH_BYTES = + 0x304d1745160d28d96a0c1f51165315f374bc28a52927f9a771e80fcb516b941f; + bytes32 private constant _NEW_SP1_AGGREGATION_VKEY_BN254 = + 0x001047d2068ac6e9b57839a587b07a254ad724d69b69c10197c0d4d2660c2fba; + bytes32 private constant _NEW_SP1_AGGREGATION_VKEY_HASH_BYTES = + 0x0823e90322b1ba6d2f0734b07b07a25456b926b46da704062f81a9a4660c2fba; + + bytes32 private constant _OLD_SGXGETH_MR_ENCLAVE = + 0x5f7da556f3b75dcc71465030e1b7274e82df9e9120c0b3eaf5bb76246a514005; + bytes32 private constant _OLD_SGXRETH_NON_EDMM_MR_ENCLAVE = + 0x3564b6a30089fcb3e2f69c19b22d23f84ce148387cd7a15f5c1df165b2ae5847; + bytes32 private constant _OLD_SGXRETH_EDMM_MR_ENCLAVE = + 0xae2c7b92b2a71238226cb624ecd1171b66bf943cc372314affca0e6748ccecdf; + bytes32 private constant _NEW_SGXGETH_MR_ENCLAVE = + 0x51701ed3fbd0bfdcea24a2e47ce9e30c5448ca9e4ad9b48bd1530d4a9c022fe4; + bytes32 private constant _NEW_SGXRETH_NON_EDMM_MR_ENCLAVE = + 0xdc994928718200e16e0eb643486ea90e49970a897fd164e39b6ae11262b69ab9; + bytes32 private constant _NEW_SGXRETH_EDMM_MR_ENCLAVE = + 0x7aaf74aaa95cf967844819e5e4504f28308541c0504e6642a12a75a4669f66a3; error ActionReverted(uint256 index); @@ -65,24 +107,26 @@ contract Proposal0026ForkTest is Test { assertEq( _implementationOf(L1.INBOX), _LIVE_INBOX_IMPL, - "L1 fork is not pre-upgrade; set L1_FORK_BLOCK=25961770 with an archive RPC" + "L1 fork is not pre-upgrade; set L1_FORK_BLOCK=26075649 with an archive RPC" ); Before memory before = _snapshot(); assertEq(before.config.basefeeSharingPctg, 75, "forked inbox does not share 75"); assertEq(before.owner, L1.DAO_CONTROLLER, "inbox is not owned by the DAO controller"); assertEq(uint8(uint256(before.slot0)), 3, "inbox initializer version is not 3"); + _assertRotationState(true, false, true); (address newImpl, Controller.Action[] memory actions) = _implementationAndBatch(); assertGt(newImpl.code.length, 0, "inbox implementation is not deployed"); - assertEq(actions.length, 1); + assertEq(actions.length, 21); - // Execute the batch the way the DAO controller will: the one upgradeTo, from the - // controller, which owns the proxy. + // Execute the complete batch the way the DAO controller will, from the controller that + // owns every target. _executeAs(L1.DAO_CONTROLLER, actions); assertEq(_implementationOf(L1.INBOX), newImpl); _assertOnlyTheSharingPercentageChanged(before); + _assertRotationState(false, true, false); } /// @dev The check `P=0026 pnpm proposal:dryrun:l1` performs: the DAO controller executes the @@ -93,15 +137,30 @@ contract Proposal0026ForkTest is Test { assertEq( _implementationOf(L1.INBOX), _LIVE_INBOX_IMPL, - "L1 fork is not pre-upgrade; set L1_FORK_BLOCK=25961770 with an archive RPC" + "L1 fork is not pre-upgrade; set L1_FORK_BLOCK=26075649 with an archive RPC" ); + Before memory before = _snapshot(); + (address sgxGethInstanceBefore,) = + IProposal0026ForkSgxVerifier(L1.SGXGETH_VERIFIER).instances(2); + (address sgxRethInstanceBefore,) = + IProposal0026ForkSgxVerifier(L1.SGXRETH_VERIFIER).instances(2); (, Controller.Action[] memory actions) = _implementationAndBatch(); + assertEq(actions.length, 21); + _assertRotationState(true, false, true); vm.expectRevert(Controller.DryrunSucceeded.selector); Controller(payable(L1.DAO_CONTROLLER)).dryrun(abi.encode(actions)); assertEq(_implementationOf(L1.INBOX), _LIVE_INBOX_IMPL, "dryrun left the proxy upgraded"); + _assertInboxUnchanged(before); + _assertRotationState(true, false, true); + (address sgxGethInstanceAfter,) = + IProposal0026ForkSgxVerifier(L1.SGXGETH_VERIFIER).instances(2); + (address sgxRethInstanceAfter,) = + IProposal0026ForkSgxVerifier(L1.SGXRETH_VERIFIER).instances(2); + assertEq(sgxGethInstanceAfter, sgxGethInstanceBefore, "dryrun deleted SGX-geth instance"); + assertEq(sgxRethInstanceAfter, sgxRethInstanceBefore, "dryrun deleted SGX-reth instance"); } /// @dev The implementation the batch upgrades to, as the proposal names it, and the committed @@ -169,6 +228,75 @@ contract Proposal0026ForkTest is Test { ); } + /// @dev Checks all state mutated by the verifier-rotation leg. The expected values are + /// independent literals rather than values read from the proposal contract. + function _assertRotationState( + bool _oldTrusted, + bool _newTrusted, + bool _instance2Active + ) + private + view + { + Risc0Verifier risc0 = Risc0Verifier(L1.RISC0_RETH_VERIFIER); + assertEq(risc0.isImageTrusted(_OLD_RISC0_PROPOSAL_IMAGE_ID), _oldTrusted); + assertEq(risc0.isImageTrusted(_OLD_RISC0_AGGREGATION_IMAGE_ID), _oldTrusted); + assertEq(risc0.isImageTrusted(_NEW_RISC0_PROPOSAL_IMAGE_ID), _newTrusted); + assertEq(risc0.isImageTrusted(_NEW_RISC0_AGGREGATION_IMAGE_ID), _newTrusted); + + SP1Verifier sp1 = SP1Verifier(L1.SP1_RETH_VERIFIER); + assertEq(sp1.isProgramTrusted(_OLD_SP1_PROPOSAL_VKEY_BN254), _oldTrusted); + assertEq(sp1.isProgramTrusted(_OLD_SP1_PROPOSAL_VKEY_HASH_BYTES), _oldTrusted); + assertEq(sp1.isProgramTrusted(_OLD_SP1_AGGREGATION_VKEY_BN254), _oldTrusted); + assertEq(sp1.isProgramTrusted(_OLD_SP1_AGGREGATION_VKEY_HASH_BYTES), _oldTrusted); + assertEq(sp1.isProgramTrusted(_NEW_SP1_PROPOSAL_VKEY_BN254), _newTrusted); + assertEq(sp1.isProgramTrusted(_NEW_SP1_PROPOSAL_VKEY_HASH_BYTES), _newTrusted); + assertEq(sp1.isProgramTrusted(_NEW_SP1_AGGREGATION_VKEY_BN254), _newTrusted); + assertEq(sp1.isProgramTrusted(_NEW_SP1_AGGREGATION_VKEY_HASH_BYTES), _newTrusted); + + IProposal0026ForkAttestation sgxGethAttester = + IProposal0026ForkAttestation(L1.SGXGETH_ATTESTER); + IProposal0026ForkAttestation sgxRethAttester = + IProposal0026ForkAttestation(L1.SGXRETH_ATTESTER); + assertEq(sgxGethAttester.trustedUserMrEnclave(_OLD_SGXGETH_MR_ENCLAVE), _oldTrusted); + assertEq( + sgxRethAttester.trustedUserMrEnclave(_OLD_SGXRETH_NON_EDMM_MR_ENCLAVE), _oldTrusted + ); + assertEq(sgxRethAttester.trustedUserMrEnclave(_OLD_SGXRETH_EDMM_MR_ENCLAVE), _oldTrusted); + assertEq(sgxGethAttester.trustedUserMrEnclave(_NEW_SGXGETH_MR_ENCLAVE), _newTrusted); + assertEq( + sgxRethAttester.trustedUserMrEnclave(_NEW_SGXRETH_NON_EDMM_MR_ENCLAVE), _newTrusted + ); + assertEq(sgxRethAttester.trustedUserMrEnclave(_NEW_SGXRETH_EDMM_MR_ENCLAVE), _newTrusted); + + (address sgxGethInstance,) = IProposal0026ForkSgxVerifier(L1.SGXGETH_VERIFIER).instances(2); + (address sgxRethInstance,) = IProposal0026ForkSgxVerifier(L1.SGXRETH_VERIFIER).instances(2); + assertEq(sgxGethInstance != address(0), _instance2Active); + assertEq(sgxRethInstance != address(0), _instance2Active); + } + + /// @dev Verifies a reverted dryrun restored the complete inbox snapshot. + function _assertInboxUnchanged(Before memory _before) private view { + Inbox inbox = Inbox(L1.INBOX); + assertEq(abi.encode(inbox.getConfig()), abi.encode(_before.config)); + assertEq(abi.encode(inbox.getCoreState()), abi.encode(_before.coreState)); + assertEq(inbox.activationTimestamp(), _before.activationTimestamp); + assertEq(inbox.owner(), _before.owner); + assertEq(vm.load(L1.INBOX, bytes32(0)), _before.slot0); + + (uint48 head, uint48 tail) = IForcedInclusionStore(L1.INBOX).getForcedInclusionState(); + assertEq(head, _before.forcedInclusionHead); + assertEq(tail, _before.forcedInclusionTail); + assertEq(inbox.getCurrentForcedInclusionFee(), _before.forcedInclusionFee); + assertEq( + inbox.getProposalHash(_before.coreState.nextProposalId - 1), _before.lastProposalHash + ); + assertEq( + inbox.getProposalHash(_before.coreState.lastFinalizedProposalId), + _before.lastFinalizedProposalHash + ); + } + /// @dev Executes `_actions` one by one from `_controller`, the way `Controller._executeActions` /// does, aborting on the first failure. The failure is a custom error rather than an assertion /// with a concatenated message: this helper has a single caller, so the via-IR build of the @@ -206,3 +334,11 @@ contract Proposal0026ForkTest is Test { impl_ = address(uint160(uint256(vm.load(_proxy, _IMPL_SLOT)))); } } + +interface IProposal0026ForkAttestation { + function trustedUserMrEnclave(bytes32 _mrEnclave) external view returns (bool); +} + +interface IProposal0026ForkSgxVerifier { + function instances(uint256 _id) external view returns (address addr_, uint64 validSince_); +} From d332dd6af4ecaa517e9787de7180d971bcc3fa5d Mon Sep 17 00:00:00 2001 From: smtmfft <99081233+smtmfft@users.noreply.github.com> Date: Mon, 28 Sep 2026 12:07:12 +0000 Subject: [PATCH 2/2] Update protocol generated artifacts --- packages/protocol/gas-reports/layer1-contracts.txt | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/packages/protocol/gas-reports/layer1-contracts.txt b/packages/protocol/gas-reports/layer1-contracts.txt index adfe6d19f99..b249704135b 100644 --- a/packages/protocol/gas-reports/layer1-contracts.txt +++ b/packages/protocol/gas-reports/layer1-contracts.txt @@ -242,11 +242,11 @@ Proposal0025Test:test_buildL2Actions_RevertsWhileAnAddressIsMissing() (gas: 4426 Proposal0025Test:test_buildL2Actions_UsesDeployedImplementations() (gas: 63219) Proposal0026ForkTest:test_l1_dryrunSucceeds() (gas: 0) Proposal0026ForkTest:test_l1_upgradesAgainstLiveState() (gas: 0) -Proposal0026Test:test_actionFileMatchesTheBuiltCalldata() (gas: 23319) -Proposal0026Test:test_buildL1Actions_EncodesTheInboxUpgrade() (gas: 13120) -Proposal0026Test:test_buildL1Actions_RevertsWhileTheImplementationIsMissing() (gas: 10675) -Proposal0026Test:test_buildL1Actions_UsesDeployedImplementation() (gas: 13820) -Proposal0026Test:test_buildL2Actions_HasNoL2Leg() (gas: 10322) +Proposal0026Test:test_actionFileMatchesTheBuiltCalldata() (gas: 113848) +Proposal0026Test:test_buildL1Actions_EncodesInboxUpgradeAndVerifierRotation() (gas: 91301) +Proposal0026Test:test_buildL1Actions_RevertsWhileTheImplementationIsMissing() (gas: 10631) +Proposal0026Test:test_buildL1Actions_UsesDeployedImplementation() (gas: 55962) +Proposal0026Test:test_buildL2Actions_HasNoL2Leg() (gas: 10411) Proposal0026Test:test_mainnetInbox_MatchesTheLiveConfigExceptForBasefeeSharing() (gas: 4703403) ProverWhitelistTest:test_init_setsOwner() (gas: 15531) ProverWhitelistTest:test_init_startsWithZeroProverCount() (gas: 15386)