optimism

diff --git official optimism/op-batcher/batcher/driver.go SWC optimism/op-batcher/batcher/driver.go index 4630df4a6f3bdd88aaa6e9a1f71ec43323b95150..308c1abbc73f9a2aa7495578afd2d0e15d2fb34e 100644 --- official optimism/op-batcher/batcher/driver.go +++ SWC optimism/op-batcher/batcher/driver.go @@ -32,8 +32,9 @@ "github.com/ethereum-optimism/optimism/op-service/txmgr" )   var ( - ErrBatcherNotRunning = errors.New("batcher is not running") - emptyTxData = txData{ + ErrBatcherNotRunning = errors.New("batcher is not running") + ErrInboxTransactionFailed = errors.New("inbox transaction failed") + emptyTxData = txData{ frames: []frameData{ { data: []byte{}, @@ -71,6 +72,7 @@ type L1Client interface { HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) + CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) }   type L2Client interface { @@ -985,6 +987,10 @@ } candidate = l.calldataTxCandidate(txdata.CallData()) }   + if *candidate.To != l.RollupConfig.BatchInboxAddress { + return fmt.Errorf("candidate.To is not inbox") + } + l.sendTx(txdata, false, candidate, queue, receiptsCh) return nil } @@ -996,12 +1002,15 @@ // sendTx uses the txmgr queue to send the given transaction candidate after setting its // gaslimit. It will block if the txmgr queue has reached its MaxPendingTransactions limit. func (l *BatchSubmitter) sendTx(txdata txData, isCancel bool, candidate *txmgr.TxCandidate, queue TxSender[txRef], receiptsCh chan txmgr.TxReceipt[txRef]) { - floorDataGas, err := core.FloorDataGas(candidate.TxData) - if err != nil { - // We log instead of return an error here because the txmgr will do its own gas estimation. - l.Log.Warn("Failed to calculate floor data gas", "err", err) - } else { - candidate.GasLimit = floorDataGas + // Leave GasLimit unset when inbox is contract so that later on `EstimateGas` will be called + if !l.RollupConfig.UseInboxContract() { + floorDataGas, err := core.FloorDataGas(candidate.TxData) + if err != nil { + // We log instead of return an error here because the txmgr will do its own gas estimation. + l.Log.Warn("Failed to calculate floor data gas", "err", err) + } else { + candidate.GasLimit = floorDataGas + } }   queue.Send(txRef{id: txdata.ID(), isCancel: isCancel, isBlob: txdata.asBlob}, *candidate, receiptsCh) @@ -1036,6 +1045,12 @@ // Record TX Status if r.Err != nil { l.recordFailedTx(r.ID.id, r.Err) } else if r.Receipt != nil { + // check tx status + if l.RollupConfig.UseInboxContract() && r.Receipt.Status == types.ReceiptStatusFailed { + l.recordFailedTx(r.ID.id, ErrInboxTransactionFailed) + return + } + l.recordConfirmedTx(r.ID.id, r.Receipt) } // Both r.Err and r.Receipt can be nil, in which case we do nothing. @@ -1053,6 +1068,7 @@ func (l *BatchSubmitter) recordFailedTx(id txID, err error) { l.channelMgrMutex.Lock() defer l.channelMgrMutex.Unlock() + l.Log.Warn("Transaction failed to send", logFields(id, err)...) l.channelMgr.TxFailed(id) }

diff --git official optimism/op-chain-ops/genesis/config.go SWC optimism/op-chain-ops/genesis/config.go index 99b07787624fd518de9e503ffae436424839ba93..2683204d242fad69264406fe351f93498819db68 100644 --- official optimism/op-chain-ops/genesis/config.go +++ SWC optimism/op-chain-ops/genesis/config.go @@ -378,6 +378,11 @@ // When Cancun activates. Relative to L1 genesis. L1CancunTimeOffset *hexutil.Uint64 `json:"l1CancunTimeOffset,omitempty"` // When Prague activates. Relative to L1 genesis. L1PragueTimeOffset *hexutil.Uint64 `json:"l1PragueTimeOffset,omitempty"` + + // QKC changes: + // L2GenesisBlobTimeOffset is the number of seconds after genesis block that the L2Blob hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable L2Blob. + L2GenesisBlobTimeOffset *hexutil.Uint64 `json:"l2GenesisBlobTimeOffset,omitempty"` // When Osaka activates. Relative to L1 genesis. L1OsakaTimeOffset *hexutil.Uint64 `json:"l1OsakaTimeOffset,omitempty"` // When BPO1 activates. Relative to L1 genesis. @@ -532,6 +537,10 @@ func (d *UpgradeScheduleDeployConfig) InteropTime(genesisTime uint64) *uint64 { return offsetToUpgradeTime(d.L2GenesisInteropTimeOffset, genesisTime) }   +func (d *UpgradeScheduleDeployConfig) L2BlobTime(genesisTime uint64) *uint64 { + return offsetToUpgradeTime(d.L2GenesisBlobTimeOffset, genesisTime) +} + func (d *UpgradeScheduleDeployConfig) AllocMode(genesisTime uint64) L2AllocsMode { forks := d.forks() for i := len(forks) - 1; i >= 0; i-- { @@ -743,6 +752,9 @@ UpgradeScheduleDeployConfig L2CoreDeployConfig FeeMarketConfig AltDADeployConfig + SoulGasTokenConfig + InboxContractConfig + L1ScalarMultiplierConfig }   func (d *L2InitializationConfig) Check(log log.Logger) error { @@ -915,6 +927,33 @@ ProtocolVersionsProxy common.Address `json:"protocolVersionsProxy"` }   +// SoulGasTokenConfig configures the SoulGasToken deployment to L2. +type SoulGasTokenConfig struct { + // DeploySoulGasToken is a flag that indicates if the SGT contract will be deploy at genesis. + DeploySoulGasToken bool `json:"deploySoulGasToken,omitempty"` + // The time offset of the block at which the SoulGasToken is activated. + SoulGasTokenTimeOffset *hexutil.Uint64 `json:"soulGasTokenTimeOffset,omitempty"` + // IsSoulBackedByNative is a flag that indicates if the SoulGasToken is backed by native. + // Only effective when DeploySoulGasToken is true. + IsSoulBackedByNative bool `json:"isSoulBackedByNative,omitempty"` +} + +func (c *SoulGasTokenConfig) SoulGasTokenTime(genesisTime uint64) *uint64 { + return offsetToUpgradeTime(c.SoulGasTokenTimeOffset, genesisTime) +} + +// InboxContractConfig configures whether inbox contract is enabled. +// If enabled, the batcher tx will be further filtered by tx status. +type InboxContractConfig struct { + UseInboxContract bool `json:"useInboxContract,omitempty"` +} + +// L1ScalarMultiplierConfig configures the scalar multipliers for L1 base fee and blob base fee. +type L1ScalarMultiplierConfig struct { + L1BaseFeeScalarMultiplier uint64 `json:"l1BaseFeeScalarMultiplier,omitempty"` + L1BlobBaseFeeScalarMultiplier uint64 `json:"l1BlobBaseFeeScalarMultiplier,omitempty"` +} + // DependencyContext is the contextual configuration needed to verify the L1 dependencies, // used by DeployConfig.CheckAddresses. type DependencyContext struct { @@ -1069,10 +1108,22 @@ if d.SystemConfigProxy == (common.Address{}) { return nil, errors.New("SystemConfigProxy cannot be address(0)") }   + l1StartTime := l1StartBlock.Time + + soulGasTokenTime := d.SoulGasTokenTime(l1StartTime) + // The SGT contract will only be deployed if DeploySoulGasToken is true. + if !d.DeploySoulGasToken && soulGasTokenTime != nil { + return nil, fmt.Errorf("soulGasTokenTimeOffset is set, but DeploySoulGasToken is false") + } chainOpConfig := &params.OptimismConfig{ - EIP1559Elasticity: d.EIP1559Elasticity, - EIP1559Denominator: d.EIP1559Denominator, - EIP1559DenominatorCanyon: &d.EIP1559DenominatorCanyon, + EIP1559Elasticity: d.EIP1559Elasticity, + EIP1559Denominator: d.EIP1559Denominator, + EIP1559DenominatorCanyon: &d.EIP1559DenominatorCanyon, + L2BlobTime: d.L2BlobTime(l1StartTime), + SoulGasTokenTime: soulGasTokenTime, + IsSoulBackedByNative: d.IsSoulBackedByNative, + L1BaseFeeScalarMultiplier: d.L1BaseFeeScalarMultiplier, + L1BlobBaseFeeScalarMultiplier: d.L1BlobBaseFeeScalarMultiplier, }   var altDA *rollup.AltDAConfig @@ -1085,7 +1136,10 @@ DAResolveWindow: d.DAResolveWindow, } }   - l1StartTime := l1StartBlock.Time + var inboxContractConfig *rollup.InboxContractConfig + if d.UseInboxContract { + inboxContractConfig = &rollup.InboxContractConfig{UseInboxContract: true} + }   return &rollup.Config{ Genesis: rollup.Genesis{ @@ -1122,6 +1176,7 @@ JovianTime: d.JovianTime(l1StartTime), InteropTime: d.InteropTime(l1StartTime), ProtocolVersionsAddress: d.ProtocolVersionsProxy, AltDAConfig: altDA, + InboxContractConfig: inboxContractConfig, ChainOpConfig: chainOpConfig, }, nil }

diff --git official optimism/op-node/rollup/derive/blob_data_source.go SWC optimism/op-node/rollup/derive/blob_data_source.go index 2c4626941b8b51cb9477c9c08dd9f6e3fb01208a..fd2f7cef1236ea9e8e7c886bf7e78a934ae4b98a 100644 --- official optimism/op-node/rollup/derive/blob_data_source.go +++ SWC optimism/op-node/rollup/derive/blob_data_source.go @@ -27,13 +27,13 @@ data []blobOrCalldata ref eth.L1BlockRef batcherAddr common.Address dsCfg DataSourceConfig - fetcher L1TransactionFetcher + fetcher L1Fetcher blobsFetcher L1BlobsFetcher log log.Logger }   // NewBlobDataSource creates a new blob data source. -func NewBlobDataSource(ctx context.Context, log log.Logger, dsCfg DataSourceConfig, fetcher L1TransactionFetcher, blobsFetcher L1BlobsFetcher, ref eth.L1BlockRef, batcherAddr common.Address) DataIter { +func NewBlobDataSource(ctx context.Context, log log.Logger, dsCfg DataSourceConfig, fetcher L1Fetcher, blobsFetcher L1BlobsFetcher, ref eth.L1BlockRef, batcherAddr common.Address) DataIter { return &BlobDataSource{ ref: ref, dsCfg: dsCfg, @@ -73,6 +73,51 @@ } return data, nil }   +// getTxSucceedMap returns a map indicating whether tx status is successful if useInboxContract; +// if !useInboxContract, nil map is returned to indicate that no status check is needed. +func getTxSucceedMap(ctx context.Context, useInboxContract bool, fetcher L1Fetcher, hash common.Hash) (txSucceeded map[common.Hash]bool, err error) { + if !useInboxContract { + return + } + _, receipts, err := fetcher.FetchReceipts(ctx, hash) + if err != nil { + return nil, NewTemporaryError(fmt.Errorf("failed to fetch L1 block info and receipts: %w", err)) + } + txSucceeded = make(map[common.Hash]bool) + for _, receipt := range receipts { + if receipt.Status == types.ReceiptStatusSuccessful { + txSucceeded[receipt.TxHash] = true + } + } + return +} + +// getTxSucceed returns all successful txs +func getTxSucceed(ctx context.Context, useInboxContract bool, fetcher L1Fetcher, hash common.Hash, txs types.Transactions) (successTxs types.Transactions, err error) { + if !useInboxContract { + // if !useInboxContract, all txs are considered successful + return txs, nil + } + _, receipts, err := fetcher.FetchReceipts(ctx, hash) + if err != nil { + return nil, NewTemporaryError(fmt.Errorf("failed to fetch L1 block info and receipts: %w", err)) + } + + txSucceeded := make(map[common.Hash]bool) + for _, receipt := range receipts { + if receipt.Status == types.ReceiptStatusSuccessful { + txSucceeded[receipt.TxHash] = true + } + } + successTxs = make(types.Transactions, 0) + for _, tx := range txs { + if _, ok := txSucceeded[tx.Hash()]; ok { + successTxs = append(successTxs, tx) + } + } + return successTxs, nil +} + // open fetches and returns the blob or calldata (as appropriate) from all valid batcher // transactions in the referenced block. Returns an empty (non-nil) array if no batcher // transactions are found. It returns ResetError if it cannot find the referenced block or a @@ -85,8 +130,12 @@ return nil, NewResetError(fmt.Errorf("failed to open blob data source: %w", err)) } return nil, NewTemporaryError(fmt.Errorf("failed to open blob data source: %w", err)) } + txSucceedMap, err := getTxSucceedMap(ctx, ds.dsCfg.useInboxContract, ds.fetcher, ds.ref.Hash) + if err != nil { + return nil, err + }   - data, hashes := dataAndHashesFromTxs(txs, &ds.dsCfg, ds.batcherAddr, ds.log) + data, hashes := dataAndHashesFromTxs(txs, &ds.dsCfg, ds.batcherAddr, ds.log, txSucceedMap)   if len(hashes) == 0 { // there are no blobs to fetch so we can return immediately @@ -115,13 +164,15 @@ // dataAndHashesFromTxs extracts calldata and datahashes from the input transactions and returns them. It // creates a placeholder blobOrCalldata element for each returned blob hash that must be populated // by fillBlobPointers after blob bodies are retrieved. -func dataAndHashesFromTxs(txs types.Transactions, config *DataSourceConfig, batcherAddr common.Address, logger log.Logger) ([]blobOrCalldata, []eth.IndexedBlobHash) { +func dataAndHashesFromTxs(txs types.Transactions, config *DataSourceConfig, batcherAddr common.Address, logger log.Logger, txSucceedMap map[common.Hash]bool) ([]blobOrCalldata, []eth.IndexedBlobHash) { data := []blobOrCalldata{} var hashes []eth.IndexedBlobHash blobIndex := 0 // index of each blob in the block's blob sidecar for _, tx := range txs { - // skip any non-batcher transactions - if !isValidBatchTx(tx, config.l1Signer, config.batchInboxAddress, batcherAddr, logger) { + // skip any non-batcher transactions or failed transactions + // blobIndex needs to be incremented for both invalid batch tx and failed tx + // if txSucceedMap is nil, it means no status check is needed. + if (!isValidBatchTx(tx, config.l1Signer, config.batchInboxAddress, batcherAddr, logger)) || (txSucceedMap != nil && !txSucceedMap[tx.Hash()]) { blobIndex += len(tx.BlobHashes()) continue }

diff --git official optimism/op-node/rollup/derive/blob_data_source_test.go SWC optimism/op-node/rollup/derive/blob_data_source_test.go index a20205544c478c35fe088d9bb782f504f5c6bf18..beb2aeadc5550b4f322c4b8418d1b8cbfec49591 100644 --- official optimism/op-node/rollup/derive/blob_data_source_test.go +++ SWC optimism/op-node/rollup/derive/blob_data_source_test.go @@ -45,7 +45,7 @@ Data: testutils.RandomData(rng, rng.Intn(1000)), } calldataTx, _ := types.SignNewTx(privateKey, signer, txData) txs := types.Transactions{calldataTx} - data, blobHashes := dataAndHashesFromTxs(txs, &config, batcherAddr, logger) + data, blobHashes := dataAndHashesFromTxs(txs, &config, batcherAddr, logger, nil) require.Equal(t, 1, len(data)) require.Equal(t, 0, len(blobHashes))   @@ -60,14 +60,14 @@ BlobHashes: []common.Hash{blobHash}, } blobTx, _ := types.SignNewTx(privateKey, signer, blobTxData) txs = types.Transactions{blobTx} - data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger) + data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger, nil) require.Equal(t, 1, len(data)) require.Equal(t, 1, len(blobHashes)) require.Nil(t, data[0].calldata)   // try again with both the blob & calldata transactions and make sure both are picked up txs = types.Transactions{blobTx, calldataTx} - data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger) + data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger, nil) require.Equal(t, 2, len(data)) require.Equal(t, 1, len(blobHashes)) require.NotNil(t, data[1].calldata) @@ -75,7 +75,7 @@ // make sure blob tx to the batch inbox is ignored if not signed by the batcher blobTx, _ = types.SignNewTx(testutils.RandomKey(), signer, blobTxData) txs = types.Transactions{blobTx} - data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger) + data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger, nil) require.Equal(t, 0, len(data)) require.Equal(t, 0, len(blobHashes))   @@ -84,7 +84,7 @@ // signature is valid. blobTxData.To = testutils.RandomAddress(rng) blobTx, _ = types.SignNewTx(privateKey, signer, blobTxData) txs = types.Transactions{blobTx} - data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger) + data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger, nil) require.Equal(t, 0, len(data)) require.Equal(t, 0, len(blobHashes))   @@ -98,9 +98,47 @@ } setCodeTx, err := types.SignNewTx(privateKey, signer, setCodeTxData) require.NoError(t, err) txs = types.Transactions{setCodeTx} - data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger) + data, blobHashes = dataAndHashesFromTxs(txs, &config, batcherAddr, logger, nil) require.Equal(t, 0, len(data)) require.Equal(t, 0, len(blobHashes)) +} + +func TestBlockWithFailedBlobTx(t *testing.T) { + // test setup + rng := rand.New(rand.NewSource(12345)) + privateKey := testutils.InsecureRandomKey(rng) + publicKey, _ := privateKey.Public().(*ecdsa.PublicKey) + batcherAddr := crypto.PubkeyToAddress(*publicKey) + batchInboxAddr := testutils.RandomAddress(rng) + logger := testlog.Logger(t, log.LvlInfo) + + chainId := new(big.Int).SetUint64(rng.Uint64()) + signer := types.NewCancunSigner(chainId) + config := DataSourceConfig{ + l1Signer: signer, + batchInboxAddress: batchInboxAddr, + } + + // create two valid blob batcher txs + var txs types.Transactions + for i := 0; i < 2; i++ { + blobHash := testutils.RandomHash(rng) + blobTxData := &types.BlobTx{ + Nonce: rng.Uint64(), + Gas: 2_000_000, + To: batchInboxAddr, + Data: testutils.RandomData(rng, rng.Intn(1000)), + BlobHashes: []common.Hash{blobHash}, + } + blobTx, _ := types.SignNewTx(privateKey, signer, blobTxData) + txs = append(txs, blobTx) + } + + // mark the first blob tx as failed + txSucceedMap := map[common.Hash]bool{txs[1].Hash(): true} + _, blobHashes := dataAndHashesFromTxs(txs, &config, batcherAddr, logger, txSucceedMap) + // check the returned blob index is 1 + require.True(t, len(blobHashes) == 1 && blobHashes[0].Index == 1) }   func TestFillBlobPointers(t *testing.T) {

diff --git official optimism/op-node/rollup/derive/calldata_source.go SWC optimism/op-node/rollup/derive/calldata_source.go index 0e8147261e93e4235c33b93f1d56be2285d96297..776428dce37b8a9099177efb526185a60e1272c0 100644 --- official optimism/op-node/rollup/derive/calldata_source.go +++ SWC optimism/op-node/rollup/derive/calldata_source.go @@ -24,7 +24,7 @@ data []eth.Data // Required to re-attempt fetching ref eth.L1BlockRef dsCfg DataSourceConfig - fetcher L1TransactionFetcher + fetcher L1Fetcher log log.Logger   batcherAddr common.Address @@ -32,7 +32,7 @@ }   // NewCalldataSource creates a new calldata source. It suppresses errors in fetching the L1 block if they occur. // If there is an error, it will attempt to fetch the result on the next call to `Next`. -func NewCalldataSource(ctx context.Context, log log.Logger, dsCfg DataSourceConfig, fetcher L1TransactionFetcher, ref eth.L1BlockRef, batcherAddr common.Address) DataIter { +func NewCalldataSource(ctx context.Context, log log.Logger, dsCfg DataSourceConfig, fetcher L1Fetcher, ref eth.L1BlockRef, batcherAddr common.Address) DataIter { _, txs, err := fetcher.InfoAndTxsByHash(ctx, ref.Hash) if err != nil { return &CalldataSource{ @@ -44,6 +44,17 @@ log: log, batcherAddr: batcherAddr, } } + txs, err = getTxSucceed(ctx, dsCfg.useInboxContract, fetcher, ref.Hash, txs) + if err != nil { + return &CalldataSource{ + open: false, + ref: ref, + dsCfg: dsCfg, + fetcher: fetcher, + log: log, + batcherAddr: batcherAddr, + } + } return &CalldataSource{ open: true, data: DataFromEVMTransactions(dsCfg, batcherAddr, txs, log.New("origin", ref)), @@ -56,6 +67,10 @@ // otherwise it returns a temporary error if fetching the block returns an error. func (ds *CalldataSource) Next(ctx context.Context) (eth.Data, error) { if !ds.open { if _, txs, err := ds.fetcher.InfoAndTxsByHash(ctx, ds.ref.Hash); err == nil { + txs, err := getTxSucceed(ctx, ds.dsCfg.useInboxContract, ds.fetcher, ds.ref.Hash, txs) + if err != nil { + return nil, err + } ds.open = true ds.data = DataFromEVMTransactions(ds.dsCfg, ds.batcherAddr, txs, ds.log) } else if errors.Is(err, ethereum.NotFound) {

diff --git official optimism/op-node/rollup/derive/calldata_source_test.go SWC optimism/op-node/rollup/derive/calldata_source_test.go index 01b2616cca3fa66be0beeff9b4e9de814f492120..31555996ddbe354a81ba2982585c18be1344c654 100644 --- official optimism/op-node/rollup/derive/calldata_source_test.go +++ SWC optimism/op-node/rollup/derive/calldata_source_test.go @@ -121,7 +121,7 @@ expectedData = append(expectedData, txs[i].Data()) } }   - out := DataFromEVMTransactions(DataSourceConfig{cfg.L1Signer(), cfg.BatchInboxAddress, false}, batcherAddr, txs, testlog.Logger(t, log.LevelCrit)) + out := DataFromEVMTransactions(DataSourceConfig{cfg.L1Signer(), cfg.BatchInboxAddress, false, false}, batcherAddr, txs, testlog.Logger(t, log.LevelCrit)) require.ElementsMatch(t, expectedData, out) }

diff --git official optimism/op-node/rollup/derive/data_source.go SWC optimism/op-node/rollup/derive/data_source.go index dfeda599501a1970dca6a52a15f99e867d0fb992..a86e0de4b98eafcb68f6bd883f2c21f5d8b2b46f 100644 --- official optimism/op-node/rollup/derive/data_source.go +++ SWC optimism/op-node/rollup/derive/data_source.go @@ -52,6 +52,7 @@ config := DataSourceConfig{ l1Signer: cfg.L1Signer(), batchInboxAddress: cfg.BatchInboxAddress, altDAEnabled: cfg.AltDAEnabled(), + useInboxContract: cfg.UseInboxContract(), } return &DataSourceFactory{ log: log, @@ -88,6 +89,7 @@ type DataSourceConfig struct { l1Signer types.Signer batchInboxAddress common.Address altDAEnabled bool + useInboxContract bool }   // isValidBatchTx returns true if:

diff --git official optimism/op-node/rollup/types.go SWC optimism/op-node/rollup/types.go index 0d64e0331187f70fe710ec40d31ecac121bc3fe2..2fc832445d96861c98b9d76157d91c9d6c9d3faf 100644 --- official optimism/op-node/rollup/types.go +++ SWC optimism/op-node/rollup/types.go @@ -152,6 +152,8 @@ // parameters to the protocol values, like the execution layer does. // If missing, it is loaded by the op-node from the embedded superchain config at startup. ChainOpConfig *params.OptimismConfig `json:"chain_op_config,omitempty"`   + InboxContractConfig *InboxContractConfig `json:"inbox_contract_config,omitempty"` + // Optional Features   // AltDAConfig. We are in the process of migrating to the AltDAConfig from these legacy top level values @@ -164,6 +166,29 @@ // blob parameters for the first L1 Prague block, as was intended. // This feature (de)activates by L1 origin timestamp, to keep a consistent L1 block info per L2 // epoch. PectraBlobScheduleTime *uint64 `json:"pectra_blob_schedule_time,omitempty"` +} + +type L2BlobConfig struct { + L2BlobTime *uint64 `json:"l2BlobTime,omitempty"` +} + +type InboxContractConfig struct { + UseInboxContract bool `json:"use_inbox_contract,omitempty"` +} + +// IsL2Blob returns whether l2 blob is enabled +func (cfg *Config) IsL2Blob(timestamp uint64) bool { + return cfg.IsL2BlobTimeSet() && *cfg.ChainOpConfig.L2BlobTime <= timestamp +} + +// UseInboxContract returns whether inbox contract is enabled +func (cfg *Config) UseInboxContract() bool { + return cfg.InboxContractConfig != nil && cfg.InboxContractConfig.UseInboxContract +} + +// IsL2BlobTimeSet returns whether l2 blob activation time is set +func (cfg *Config) IsL2BlobTimeSet() bool { + return cfg.ChainOpConfig != nil && cfg.ChainOpConfig.L2BlobTime != nil }   // ValidateL1Config checks L1 config variables for errors. @@ -773,6 +798,12 @@ banner += "Post-Bedrock Network Upgrades (timestamp based):\n" c.forEachFork(func(name string, _ string, time *uint64) { banner += fmt.Sprintf(" - %v: %s\n", name, fmtForkTimeOrUnset(time)) }) + var l2BlobTime *uint64 + if c.ChainOpConfig != nil { + l2BlobTime = c.ChainOpConfig.L2BlobTime + } + banner += fmt.Sprintf(" - L2Blob: %s\n", fmtForkTimeOrUnset(l2BlobTime)) + banner += fmt.Sprintf(" - Use inbox contract: %v\n", c.UseInboxContract()) // Report the protocol version banner += fmt.Sprintf("Node supports up to OP-Stack Protocol Version: %s\n", OPStackSupport) if c.AltDAConfig != nil { @@ -815,6 +846,13 @@ }) if c.AltDAConfig != nil { ctx = append(ctx, "alt_da", *c.AltDAConfig) } + + var l2BlobTime *uint64 + if c.ChainOpConfig != nil { + l2BlobTime = c.ChainOpConfig.L2BlobTime + } + ctx = append(ctx, "l2_blob_config", fmtForkTimeOrUnset(l2BlobTime)) + ctx = append(ctx, "use_inbox_contract", c.UseInboxContract()) log.Info("Rollup Config", ctx...) }

diff --git official optimism/op-chain-ops/genesis/genesis.go SWC optimism/op-chain-ops/genesis/genesis.go index 306f70df2dd5d999f5601c36f16cb9c69cb0e497..94f02286d53acc62d067d23fad2d66ddb3d4cff2 100644 --- official optimism/op-chain-ops/genesis/genesis.go +++ SWC optimism/op-chain-ops/genesis/genesis.go @@ -46,6 +46,12 @@ }   l1StartTime := l1StartHeader.Time   + soulGasTokenTime := config.SoulGasTokenTime(l1StartTime) + // The SGT contract will only be deployed if DeploySoulGasToken is true. + if !config.DeploySoulGasToken && soulGasTokenTime != nil { + return nil, fmt.Errorf("soulGasTokenTimeOffset is set, but DeploySoulGasToken is false") + } + optimismChainConfig := params.ChainConfig{ ChainID: new(big.Int).SetUint64(config.L2ChainID), HomesteadBlock: big.NewInt(0), @@ -79,9 +85,14 @@ JovianTime: config.JovianTime(l1StartTime), PragueTime: config.IsthmusTime(l1StartTime), InteropTime: config.InteropTime(l1StartTime), Optimism: &params.OptimismConfig{ - EIP1559Denominator: eip1559Denom, - EIP1559Elasticity: eip1559Elasticity, - EIP1559DenominatorCanyon: &eip1559DenomCanyon, + EIP1559Denominator: eip1559Denom, + EIP1559Elasticity: eip1559Elasticity, + EIP1559DenominatorCanyon: &eip1559DenomCanyon, + L2BlobTime: config.L2BlobTime(l1StartTime), + IsSoulBackedByNative: config.IsSoulBackedByNative, + SoulGasTokenTime: soulGasTokenTime, + L1BaseFeeScalarMultiplier: config.L1BaseFeeScalarMultiplier, + L1BlobBaseFeeScalarMultiplier: config.L1BlobBaseFeeScalarMultiplier, }, }

diff --git official optimism/op-service/predeploys/addresses.go SWC optimism/op-service/predeploys/addresses.go index e461f0c86faaf596bbd3ec9914e8b5ee6dd21b93..de20083e3d0aa4c675d82936e82525baab74e15d 100644 --- official optimism/op-service/predeploys/addresses.go +++ SWC optimism/op-service/predeploys/addresses.go @@ -26,6 +26,7 @@ L1FeeVault = "0x420000000000000000000000000000000000001a" OperatorFeeVault = "0x420000000000000000000000000000000000001b" SchemaRegistry = "0x4200000000000000000000000000000000000020" EAS = "0x4200000000000000000000000000000000000021" + SoulGasToken = "0x4200000000000000000000000000000000000800" CrossL2Inbox = "0x4200000000000000000000000000000000000022" L2toL2CrossDomainMessenger = "0x4200000000000000000000000000000000000023" SuperchainETHBridge = "0x4200000000000000000000000000000000000024" @@ -67,6 +68,7 @@ L1FeeVaultAddr = common.HexToAddress(L1FeeVault) OperatorFeeVaultAddr = common.HexToAddress(OperatorFeeVault) SchemaRegistryAddr = common.HexToAddress(SchemaRegistry) EASAddr = common.HexToAddress(EAS) + SoulGasTokenAddr = common.HexToAddress(SoulGasToken) CrossL2InboxAddr = common.HexToAddress(CrossL2Inbox) L2toL2CrossDomainMessengerAddr = common.HexToAddress(L2toL2CrossDomainMessenger) SuperchainETHBridgeAddr = common.HexToAddress(SuperchainETHBridge) @@ -122,6 +124,7 @@ Predeploys["L1FeeVault"] = &Predeploy{Address: L1FeeVaultAddr} Predeploys["OperatorFeeVault"] = &Predeploy{Address: OperatorFeeVaultAddr} Predeploys["SchemaRegistry"] = &Predeploy{Address: SchemaRegistryAddr} Predeploys["EAS"] = &Predeploy{Address: EASAddr} + Predeploys["SoulGasToken"] = &Predeploy{Address: SoulGasTokenAddr} Predeploys["Create2Deployer"] = &Predeploy{ Address: Create2DeployerAddr, ProxyDisabled: true,

diff --git official optimism/packages/contracts-bedrock/interfaces/L2/ISoulGasToken.sol SWC optimism/packages/contracts-bedrock/interfaces/L2/ISoulGasToken.sol new file mode 100644 index 0000000000000000000000000000000000000000..096b42f7a41172bb0aacba7d2121bfa4d1f9939d --- /dev/null +++ SWC optimism/packages/contracts-bedrock/interfaces/L2/ISoulGasToken.sol @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +/// @title ISoulGasToken +/// @notice The interface for the SoulGasToken. +interface ISoulGasToken { + function initialize(string memory _name, string memory _symbol, address _owner) external; + + function __constructor__(bool _isBackedByNative) external; + + function name() external view returns (string memory); + function symbol() external view returns (string memory); + function owner() external view returns (address); + function admin() external view returns (address); +}

diff --git official optimism/packages/contracts-bedrock/scripts/Artifacts.s.sol SWC optimism/packages/contracts-bedrock/scripts/Artifacts.s.sol index 5858c8aa4c59705788b859231522aac25ede2e79..7d5471ba49b73c35e4b9d55640403a86094bc572 100644 --- official optimism/packages/contracts-bedrock/scripts/Artifacts.s.sol +++ SWC optimism/packages/contracts-bedrock/scripts/Artifacts.s.sol @@ -80,6 +80,8 @@ bytes32 digest = keccak256(bytes(_name)); if (digest == keccak256(bytes("L2CrossDomainMessenger"))) { return payable(Predeploys.L2_CROSS_DOMAIN_MESSENGER); + } else if (digest == keccak256(bytes("SoulGasToken"))) { + return payable(Predeploys.SOUL_GAS_TOKEN); } else if (digest == keccak256(bytes("L2ToL1MessagePasser"))) { return payable(Predeploys.L2_TO_L1_MESSAGE_PASSER); } else if (digest == keccak256(bytes("L2StandardBridge"))) {

diff --git official optimism/packages/contracts-bedrock/scripts/L2Genesis.s.sol SWC optimism/packages/contracts-bedrock/scripts/L2Genesis.s.sol index 5708dfe33c7a16c76bdff5bbbd7798d8d422182e..ba05e3632f630642c2bf0414524483a0978543a0 100644 --- official optimism/packages/contracts-bedrock/scripts/L2Genesis.s.sol +++ SWC optimism/packages/contracts-bedrock/scripts/L2Genesis.s.sol @@ -31,6 +31,8 @@ import { IL2CrossDomainMessenger } from "interfaces/L2/IL2CrossDomainMessenger.sol"; import { IGasPriceOracle } from "interfaces/L2/IGasPriceOracle.sol"; import { IL1Block } from "interfaces/L2/IL1Block.sol";   +import { SoulGasToken } from "src/L2/SoulGasToken.sol"; + /// @title L2Genesis /// @notice Generates the genesis state for the L2 network. /// The following safety invariants are used when setting state: @@ -60,6 +62,8 @@ uint256 fork; bool deployCrossL2Inbox; bool enableGovernance; bool fundDevAccounts; + bool deploySoulGasToken; + bool isSoulBackedByNative; }   using ForkUtils for Fork; @@ -231,6 +235,7 @@ setOperatorFeeVault(); // 1B // 1C,1D,1E,1F: not used. setSchemaRegistry(); // 20 setEAS(); // 21 + if (_input.deploySoulGasToken) setSoulGasToken(_input); // 800 setGovernanceToken(_input); // 42: OP (not behind a proxy) if (_input.fork >= uint256(Fork.INTEROP)) { if (_input.deployCrossL2Inbox) { @@ -256,6 +261,25 @@ }   function setL2ToL1MessagePasser() internal { _setImplementationCode(Predeploys.L2_TO_L1_MESSAGE_PASSER); + } + + /// @notice This predeploy is following the safety invariant #2. + function setSoulGasToken(Input memory _input) public { + address impl = Predeploys.predeployToCodeNamespace(Predeploys.SOUL_GAS_TOKEN); + + SoulGasToken token = new SoulGasToken({ _isBackedByNative: _input.isSoulBackedByNative }); + vm.etch(impl, address(token).code); + + /// Reset so its not included state dump + vm.etch(address(token), ""); + vm.resetNonce(address(token)); + + SoulGasToken(impl).initialize({ _name: "", _symbol: "", _owner: _input.opChainProxyAdminOwner }); + SoulGasToken(Predeploys.SOUL_GAS_TOKEN).initialize({ + _name: "SoulQKC", + _symbol: "SoulQKC", + _owner: _input.opChainProxyAdminOwner + }); }   /// @notice This predeploy is following the safety invariant #1.

diff --git official optimism/packages/contracts-bedrock/scripts/deploy/DeployConfig.s.sol SWC optimism/packages/contracts-bedrock/scripts/deploy/DeployConfig.s.sol index 928faad8129bc2cc60915e1aea2a68f8b6e9e995..bfda16442e540dfd91d493441d8b45d598cc9e80 100644 --- official optimism/packages/contracts-bedrock/scripts/deploy/DeployConfig.s.sol +++ SWC optimism/packages/contracts-bedrock/scripts/deploy/DeployConfig.s.sol @@ -83,6 +83,8 @@ uint256 public faultGameV2ClockExtension; uint256 public faultGameV2MaxClockDuration;   bool public useInterop; + bool public deploySoulGasToken; + bool public isSoulBackedByNative; bool public useUpgradedFork; bytes32 public devFeatureBitmap;   @@ -158,6 +160,8 @@ daBondSize = _readOr(_json, "$.daBondSize", 1000000000); daResolverRefundPercentage = _readOr(_json, "$.daResolverRefundPercentage", 0);   useInterop = _readOr(_json, "$.useInterop", false); + deploySoulGasToken = _readOr(_json, "$.deploySoulGasToken", false); + isSoulBackedByNative = _readOr(_json, "$.isSoulBackedByNative", false); devFeatureBitmap = bytes32(_readOr(_json, "$.devFeatureBitmap", 0)); useUpgradedFork; faultGameV2MaxGameDepth = _readOr(_json, "$.faultGameV2MaxGameDepth", 73); @@ -213,6 +217,16 @@ /// @notice Allow the `useInterop` config to be overridden in testing environments function setUseInterop(bool _useInterop) public { useInterop = _useInterop; + } + + /// @notice Allow the `deploySoulGasToken` config to be overridden in testing environments + function setDeploySoulGasToken(bool _deploySoulGasToken) public { + deploySoulGasToken = _deploySoulGasToken; + } + + /// @notice Allow the `isSoulBackedByNative` config to be overridden in testing environments + function setIsSoulBackedByNative(bool _isSoulBackedByNative) public { + isSoulBackedByNative = _isSoulBackedByNative; }   /// @notice Allow the `fundDevAccounts` config to be overridden.

diff --git official optimism/packages/contracts-bedrock/src/L2/SoulGasToken.sol SWC optimism/packages/contracts-bedrock/src/L2/SoulGasToken.sol new file mode 100644 index 0000000000000000000000000000000000000000..5a23f83bcd0d1935ed3599f98a2435008ec6a4ed --- /dev/null +++ SWC optimism/packages/contracts-bedrock/src/L2/SoulGasToken.sol @@ -0,0 +1,266 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +import { ERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol"; +import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; + +/// @title SoulGasToken +/// @notice The SoulGasToken is a soul-bounded ERC20 contract which can be used to pay gas on L2. +/// It has 2 modes: +/// 1. when IS_BACKED_BY_NATIVE(or in other words: SoulQKC mode), the token can be minted by +/// anyone depositing native token into the contract. +/// 2. when !IS_BACKED_BY_NATIVE(or in other words: SoulETH mode), the token can only be +/// minted by whitelist minters specified by contract owner. +contract SoulGasToken is ERC20Upgradeable, OwnableUpgradeable { + /// @custom:storage-location erc7201:openzeppelin.storage.SoulGasToken + struct SoulGasTokenStorage { + // minters are whitelist EOAs, only used when !IS_BACKED_BY_NATIVE + mapping(address => bool) minters; + // burners are whitelist EOAs to burn/withdraw SoulGasToken + mapping(address => bool) burners; + // allowSgtValue are whitelist contracts to consume sgt as msg.value + // when IS_BACKED_BY_NATIVE + mapping(address => bool) allowSgtValue; + } + + /// @notice Emitted when sgt as msg.value is enabled for a contract. + /// @param from Address of the contract for which sgt as msg.value is enabled. + event AllowSgtValue(address indexed from); + /// @notice Emitted when sgt as msg.value is disabled for a contract. + /// @param from Address of the contract for which sgt as msg.value is disabled. + event DisallowSgtValue(address indexed from); + + event BurnerAdded(address indexed burner); + event BurnerDeleted(address indexed burner); + event MinterAdded(address indexed minter); + event MinterDeleted(address indexed minter); + + // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.SoulGasToken")) - 1)) & ~bytes32(uint256(0xff)) + bytes32 private constant _SOULGASTOKEN_STORAGE_LOCATION = + 0x135c38e215d95c59dcdd8fe622dccc30d04cacb8c88c332e4e7441bac172dd00; + + bool internal immutable IS_BACKED_BY_NATIVE; + + function _getSoulGasTokenStorage() private pure returns (SoulGasTokenStorage storage $) { + assembly { + $.slot := _SOULGASTOKEN_STORAGE_LOCATION + } + } + + constructor(bool _isBackedByNative) { + IS_BACKED_BY_NATIVE = _isBackedByNative; + initialize("", "", msg.sender); + } + + /// @notice Initializer. + function initialize(string memory _name, string memory _symbol, address _owner) public initializer { + __Ownable_init(); + transferOwnership(_owner); + + // initialize the inherited ERC20Upgradeable + __ERC20_init(_name, _symbol); + } + + /// @notice deposit can be called by anyone to deposit native token for SoulGasToken when + /// IS_BACKED_BY_NATIVE. + function deposit() external payable { + require(IS_BACKED_BY_NATIVE, "SGT: deposit should only be called when IS_BACKED_BY_NATIVE"); + + _mint(_msgSender(), msg.value); + } + + /// @notice batchDepositFor can be called by anyone to deposit native token for SoulGasToken in batch when + /// IS_BACKED_BY_NATIVE. + function batchDepositFor(address[] calldata _accounts, uint256[] calldata _values) external payable { + require(_accounts.length == _values.length, "SGT: invalid arguments"); + + require(IS_BACKED_BY_NATIVE, "SGT: batchDepositFor should only be called when IS_BACKED_BY_NATIVE"); + + uint256 totalValue = 0; + for (uint256 i = 0; i < _accounts.length; i++) { + _mint(_accounts[i], _values[i]); + totalValue += _values[i]; + } + require(msg.value == totalValue, "SGT: unexpected msg.value"); + } + + /// @notice batchDepositForAll is similar to batchDepositFor, but the value is the same for all accounts. + function batchDepositForAll(address[] calldata _accounts, uint256 _value) external payable { + require(IS_BACKED_BY_NATIVE, "SGT: batchDepositForAll should only be called when IS_BACKED_BY_NATIVE"); + + for (uint256 i = 0; i < _accounts.length; i++) { + _mint(_accounts[i], _value); + } + require(msg.value == _value * _accounts.length, "SGT: unexpected msg.value"); + } + + /// @notice withdrawFrom is called by the burner to burn SoulGasToken and return the native token when + /// IS_BACKED_BY_NATIVE. + function withdrawFrom(address _account, uint256 _value) external { + require(IS_BACKED_BY_NATIVE, "SGT: withdrawFrom should only be called when IS_BACKED_BY_NATIVE"); + + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + require($.burners[_msgSender()], "SGT: not the burner"); + + _burn(_account, _value); + payable(_msgSender()).transfer(_value); + } + + /// @notice batchWithdrawFrom is the batch version of withdrawFrom. + function batchWithdrawFrom(address[] calldata _accounts, uint256[] calldata _values) external { + require(_accounts.length == _values.length, "SGT: invalid arguments"); + + require(IS_BACKED_BY_NATIVE, "SGT: batchWithdrawFrom should only be called when IS_BACKED_BY_NATIVE"); + + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + require($.burners[_msgSender()], "SGT: not the burner"); + + uint256 totalValue = 0; + for (uint256 i = 0; i < _accounts.length; i++) { + _burn(_accounts[i], _values[i]); + totalValue += _values[i]; + } + + payable(_msgSender()).transfer(totalValue); + } + + /// @notice batchMint is called: + /// 1. by EOA minters to mint SoulGasToken in batch when !IS_BACKED_BY_NATIVE. + function batchMint(address[] calldata _accounts, uint256[] calldata _values) external { + // we don't explicitly check !IS_BACKED_BY_NATIVE here, because if IS_BACKED_BY_NATIVE, + // there's no way to add a minter. + require(_accounts.length == _values.length, "SGT: invalid arguments"); + + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + require($.minters[_msgSender()], "SGT: not a minter"); + + for (uint256 i = 0; i < _accounts.length; i++) { + _mint(_accounts[i], _values[i]); + } + } + + /// @notice addMinters is called by the owner to add minters when !IS_BACKED_BY_NATIVE. + function addMinters(address[] calldata _minters) external onlyOwner { + require(!IS_BACKED_BY_NATIVE, "SGT: addMinters should only be called when !IS_BACKED_BY_NATIVE"); + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + uint256 i; + for (i = 0; i < _minters.length; i++) { + $.minters[_minters[i]] = true; + emit MinterAdded(_minters[i]); + } + } + + /// @notice delMinters is called by the owner to delete minters when !IS_BACKED_BY_NATIVE. + function delMinters(address[] calldata _minters) external onlyOwner { + require(!IS_BACKED_BY_NATIVE, "SGT: delMinters should only be called when !IS_BACKED_BY_NATIVE"); + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + uint256 i; + for (i = 0; i < _minters.length; i++) { + delete $.minters[_minters[i]]; + emit MinterDeleted(_minters[i]); + } + } + + /// @notice addBurners is called by the owner to add burners. + function addBurners(address[] calldata _burners) external onlyOwner { + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + uint256 i; + for (i = 0; i < _burners.length; i++) { + $.burners[_burners[i]] = true; + emit BurnerAdded(_burners[i]); + } + } + + /// @notice delBurners is called by the owner to delete burners. + function delBurners(address[] calldata _burners) external onlyOwner { + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + uint256 i; + for (i = 0; i < _burners.length; i++) { + delete $.burners[_burners[i]]; + emit BurnerDeleted(_burners[i]); + } + } + + /// @notice allowSgtValue is called by the owner to enable whitelist contracts to consume sgt as msg.value + function allowSgtValue(address[] calldata _contracts) external onlyOwner { + require(IS_BACKED_BY_NATIVE, "SGT: allowSgtValue should only be called when IS_BACKED_BY_NATIVE"); + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + uint256 i; + for (i = 0; i < _contracts.length; i++) { + $.allowSgtValue[_contracts[i]] = true; + emit AllowSgtValue(_contracts[i]); + } + } + + /// @notice allowSgtValue is called by the owner to disable whitelist contracts to consume sgt as msg.value + function disallowSgtValue(address[] calldata _contracts) external onlyOwner { + require(IS_BACKED_BY_NATIVE, "SGT: disallowSgtValue should only be called when IS_BACKED_BY_NATIVE"); + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + uint256 i; + for (i = 0; i < _contracts.length; i++) { + $.allowSgtValue[_contracts[i]] = false; + emit DisallowSgtValue(_contracts[i]); + } + } + + /// @notice chargeFromOrigin is called when IS_BACKED_BY_NATIVE to charge for native balance + /// from tx.origin if caller is whitelisted. + function chargeFromOrigin(uint256 _amount) external returns (uint256 amountCharged_) { + require(IS_BACKED_BY_NATIVE, "SGT: chargeFromOrigin should only be called when IS_BACKED_BY_NATIVE"); + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + require($.allowSgtValue[_msgSender()], "SGT: caller is not whitelisted"); + uint256 balance = balanceOf(tx.origin); + if (balance == 0) { + amountCharged_ = 0; + return amountCharged_; + } + if (balance >= _amount) { + amountCharged_ = _amount; + } else { + amountCharged_ = balance; + } + _burn(tx.origin, amountCharged_); + payable(_msgSender()).transfer(amountCharged_); + } + + /// @notice burnFrom is called when !IS_BACKED_BY_NATIVE: + /// 1. by the burner to burn SoulGasToken. + function burnFrom(address _account, uint256 _value) external { + require(!IS_BACKED_BY_NATIVE, "SGT: burnFrom should only be called when !IS_BACKED_BY_NATIVE"); + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + require($.burners[_msgSender()], "SGT: not the burner"); + _burn(_account, _value); + } + + /// @notice batchBurnFrom is the batch version of burnFrom. + function batchBurnFrom(address[] calldata _accounts, uint256[] calldata _values) external { + require(_accounts.length == _values.length, "SGT: invalid arguments"); + require(!IS_BACKED_BY_NATIVE, "SGT: batchBurnFrom should only be called when !IS_BACKED_BY_NATIVE"); + SoulGasTokenStorage storage $ = _getSoulGasTokenStorage(); + require($.burners[_msgSender()], "SGT: not the burner"); + + for (uint256 i = 0; i < _accounts.length; i++) { + _burn(_accounts[i], _values[i]); + } + } + + /// @notice transferFrom is disabled for SoulGasToken. + function transfer(address, uint256) public virtual override returns (bool) { + revert("SGT: transfer is disabled for SoulGasToken"); + } + + /// @notice transferFrom is disabled for SoulGasToken. + function transferFrom(address, address, uint256) public virtual override returns (bool) { + revert("SGT: transferFrom is disabled for SoulGasToken"); + } + + /// @notice approve is disabled for SoulGasToken. + function approve(address, uint256) public virtual override returns (bool) { + revert("SGT: approve is disabled for SoulGasToken"); + } + + /// @notice Returns whether SoulGasToken is backed by native token. + function isBackedByNative() external view returns (bool) { + return IS_BACKED_BY_NATIVE; + } +}

diff --git official optimism/packages/contracts-bedrock/src/libraries/Predeploys.sol SWC optimism/packages/contracts-bedrock/src/libraries/Predeploys.sol index baeb6a143575c6bcf59876f160edf7a21169914c..859a26cbac2508e4652af200816d469a623a59f0 100644 --- official optimism/packages/contracts-bedrock/src/libraries/Predeploys.sol +++ SWC optimism/packages/contracts-bedrock/src/libraries/Predeploys.sol @@ -8,7 +8,7 @@ /// @notice Contains constant addresses for protocol contracts that are pre-deployed to the L2 system. // This excludes the preinstalls (non-protocol contracts). library Predeploys { /// @notice Number of predeploy-namespace addresses reserved for protocol usage. - uint256 internal constant PREDEPLOY_COUNT = 2048; + uint256 internal constant PREDEPLOY_COUNT = 4096;   /// @custom:legacy /// @notice Address of the LegacyMessagePasser predeploy. Deprecate. Use the updated @@ -78,6 +78,9 @@ address internal constant SCHEMA_REGISTRY = 0x4200000000000000000000000000000000000020;   /// @notice Address of the EAS predeploy. address internal constant EAS = 0x4200000000000000000000000000000000000021; + + /// @notice Address of the SOUL_GAS_TOKEN predeploy. + address internal constant SOUL_GAS_TOKEN = 0x4200000000000000000000000000000000000800;   /// @notice Address of the GovernanceToken predeploy. address internal constant GOVERNANCE_TOKEN = 0x4200000000000000000000000000000000000042; @@ -145,6 +148,7 @@ if (_addr == ETH_LIQUIDITY) return "ETHLiquidity"; if (_addr == OPTIMISM_SUPERCHAIN_ERC20_FACTORY) return "OptimismSuperchainERC20Factory"; if (_addr == OPTIMISM_SUPERCHAIN_ERC20_BEACON) return "OptimismSuperchainERC20Beacon"; if (_addr == SUPERCHAIN_TOKEN_BRIDGE) return "SuperchainTokenBridge"; + if (_addr == SOUL_GAS_TOKEN) return "SoulGasToken"; revert("Predeploys: unnamed predeploy"); }   @@ -171,11 +175,11 @@ || _addr == OPTIMISM_MINTABLE_ERC721_FACTORY || _addr == PROXY_ADMIN || _addr == BASE_FEE_VAULT || _addr == L1_FEE_VAULT || _addr == OPERATOR_FEE_VAULT || _addr == SCHEMA_REGISTRY || _addr == EAS || _addr == GOVERNANCE_TOKEN || (_fork >= uint256(Fork.INTEROP) && _enableCrossL2Inbox && _addr == CROSS_L2_INBOX) - || (_fork >= uint256(Fork.INTEROP) && _addr == L2_TO_L2_CROSS_DOMAIN_MESSENGER); + || (_fork >= uint256(Fork.INTEROP) && _addr == L2_TO_L2_CROSS_DOMAIN_MESSENGER) || _addr == SOUL_GAS_TOKEN; }   function isPredeployNamespace(address _addr) internal pure returns (bool) { - return uint160(_addr) >> 11 == uint160(0x4200000000000000000000000000000000000000) >> 11; + return uint160(_addr) >> 12 == uint160(0x4200000000000000000000000000000000000000) >> 12; }   /// @notice Function to compute the expected address of the predeploy implementation

diff --git official optimism/op-node/flags/flags.go SWC optimism/op-node/flags/flags.go index e72383527234ae3fb69939ad5b5022ab3216ba22..8a9abf056e31bd26eb1533750005cc98c2b87c24 100644 --- official optimism/op-node/flags/flags.go +++ SWC optimism/op-node/flags/flags.go @@ -368,6 +368,12 @@ EnvVars: prefixEnvVars("CONDUCTOR_RPC_TIMEOUT"), Value: time.Second * 1, Category: SequencerCategory, } + DACUrlsFlag = &cli.StringFlag{ + Name: "dac.urls", + Usage: "dac urls for sequencer when l2 blob is enabled", + EnvVars: prefixEnvVars("DAC_URLS"), + Category: SequencerCategory, + } /* Interop flags, experimental. */ InteropRPCAddr = &cli.StringFlag{ Name: "interop.rpc.addr", @@ -465,6 +471,7 @@ ConductorRpcTimeoutFlag, SafeDBPath, L1ChainConfig, L2EngineKind, + DACUrlsFlag, L2EngineRpcTimeout, InteropRPCAddr, InteropRPCPort,

diff --git official optimism/op-node/node/node.go SWC optimism/op-node/node/node.go index b0ea946651d8e1a742fb64a44c50ecf208a65b95..13dd821b7746e0cac8018537c145259017401712 100644 --- official optimism/op-node/node/node.go +++ SWC optimism/op-node/node/node.go @@ -583,12 +583,13 @@ } else { safeDB = safedb.Disabled }   + dacClient := cfg.DACConfig.Client() if cfg.Rollup.ChainOpConfig == nil { return nil, nil, nil, nil, fmt.Errorf("cfg.Rollup.ChainOpConfig is nil. Please see https://github.com/ethereum-optimism/optimism/releases/tag/op-node/v1.11.0: %w", err) }   l2Driver := driver.NewDriver(node.eventSys, node.eventDrain, &cfg.Driver, &cfg.Rollup, cfg.L1ChainConfig, cfg.DependencySet, l2Source, node.l1Source, - node.beacon, node, node, node.log, node.metrics, cfg.ConfigPersistence, safeDB, &cfg.Sync, sequencerConductor, altDA, indexingMode) + node.beacon, node, node, node.log, node.metrics, cfg.ConfigPersistence, safeDB, &cfg.Sync, sequencerConductor, altDA, indexingMode, dacClient)   // Wire up IndexingMode to engine controller for direct procedure call if sys != nil {

diff --git official optimism/op-node/p2p/gossip.go SWC optimism/op-node/p2p/gossip.go index 2a8442a9d238f931145889ae920742c902f896c1..9d4b2a5c704904a2c7ff2b1071ff31bca4b93c14 100644 --- official optimism/op-node/p2p/gossip.go +++ SWC optimism/op-node/p2p/gossip.go @@ -334,7 +334,7 @@ now := uint64(time.Now().Unix())   // [REJECT] if the `payload.timestamp` is older than the configured threshold threshold := uint64(gossipConf.GetGossipTimestampThreshold().Seconds()) - if uint64(payload.Timestamp) < now-threshold { + if uint64(payload.Timestamp) < now-threshold || uint64(payload.Timestamp) < cfg.BlockTime /* ensure timestamp>=BlockTime since we'll do subtraction below */ { log.Warn("payload is too old", "timestamp", uint64(payload.Timestamp), "threshold_seconds", threshold) return pubsub.ValidationReject } @@ -387,14 +387,15 @@ if payload.BlobGasUsed == nil { log.Warn("payload is on v3 topic, but has nil blob gas used", "bad_hash", payload.BlockHash.String()) return pubsub.ValidationReject // [REJECT] if the block is on a topic >= V3 and has a non-zero blob gas used field pre-Jovian - } else if !cfg.IsDAFootprintBlockLimit(uint64(payload.Timestamp)) && *payload.BlobGasUsed != 0 { + } else if !(cfg.IsDAFootprintBlockLimit(uint64(payload.Timestamp)) || cfg.IsL2Blob(uint64(payload.Timestamp)-cfg.BlockTime)) && *payload.BlobGasUsed != 0 { log.Warn("payload is on v3 topic, but has non-zero blob gas used", "bad_hash", payload.BlockHash.String(), "blob_gas_used", *payload.BlobGasUsed) return pubsub.ValidationReject }   // [REJECT] if the block is on a topic >= V3 and has an excess blob gas value that is not zero - if payload.ExcessBlobGas == nil || *payload.ExcessBlobGas != 0 { + + if payload.ExcessBlobGas == nil || (!cfg.IsL2Blob(uint64(payload.Timestamp)-cfg.BlockTime) && *payload.ExcessBlobGas != 0) { log.Warn("payload is on v3 topic, but has non-zero excess blob gas", "bad_hash", payload.BlockHash.String(), "excess_blob_gas", ptr.Str(payload.ExcessBlobGas)) return pubsub.ValidationReject

diff --git official optimism/op-node/rollup/derive/span_batch_tx.go SWC optimism/op-node/rollup/derive/span_batch_tx.go index 876fbd9347f27566b571b3f0d09e1f600f6ba0ec..3d8e5a01962120470eff853522b23838ee287f3c 100644 --- official optimism/op-node/rollup/derive/span_batch_tx.go +++ SWC optimism/op-node/rollup/derive/span_batch_tx.go @@ -46,6 +46,18 @@ }   func (txData *spanBatchDynamicFeeTxData) txType() byte { return types.DynamicFeeTxType }   +type spanBatchBlobTxData struct { + Value *uint256.Int + GasTipCap *uint256.Int // a.k.a. maxPriorityFeePerGas + GasFeeCap *uint256.Int // a.k.a. maxFeePerGas + Data []byte + AccessList types.AccessList + BlobFeeCap *uint256.Int // a.k.a. maxFeePerBlobGas + BlobHashes []common.Hash +} + +func (txData *spanBatchBlobTxData) txType() byte { return types.BlobTxType } + type spanBatchSetCodeTxData struct { Value *uint256.Int GasTipCap *uint256.Int // a.k.a. maxPriorityFeePerGas @@ -103,6 +115,13 @@ var inner spanBatchDynamicFeeTxData err := rlp.DecodeBytes(b[1:], &inner) if err != nil { return nil, fmt.Errorf("failed to decode spanBatchDynamicFeeTxData: %w", err) + } + return &inner, nil + case types.BlobTxType: + var inner spanBatchBlobTxData + err := rlp.DecodeBytes(b[1:], &inner) + if err != nil { + return nil, fmt.Errorf("failed to decode spanBatchBlobTxData: %w", err) } return &inner, nil case types.SetCodeTxType: @@ -187,6 +206,39 @@ V: V, R: R, S: S, } + case types.BlobTxType: + if to == nil { + return nil, fmt.Errorf("invalid blob tx: to can't be nil") + } + VU256, overflow := uint256.FromBig(V) + if overflow { + return nil, fmt.Errorf("invalid blob tx: V overflow:%v", V) + } + RU256, overflow := uint256.FromBig(R) + if overflow { + return nil, fmt.Errorf("invalid blob tx: R overflow:%v", R) + } + SU256, overflow := uint256.FromBig(S) + if overflow { + return nil, fmt.Errorf("invalid blob tx: S overflow:%v", R) + } + batchTxInner := tx.inner.(*spanBatchBlobTxData) + inner = &types.BlobTx{ + ChainID: uint256.MustFromBig(chainID), + Nonce: nonce, + GasTipCap: batchTxInner.GasTipCap, + GasFeeCap: batchTxInner.GasFeeCap, + Gas: gas, + To: *to, + Value: batchTxInner.Value, + Data: batchTxInner.Data, + AccessList: batchTxInner.AccessList, + BlobFeeCap: batchTxInner.BlobFeeCap, + BlobHashes: batchTxInner.BlobHashes, + V: VU256, + R: RU256, + S: SU256, + } case types.SetCodeTxType: if to == nil { return nil, fmt.Errorf("to address is required for SetCodeTx") @@ -238,6 +290,32 @@ GasFeeCap: tx.GasFeeCap(), Value: tx.Value(), Data: tx.Data(), AccessList: tx.AccessList(), + } + case types.BlobTxType: + gasTipCap, overflow := uint256.FromBig(tx.GasTipCap()) + if overflow { + return nil, fmt.Errorf("tx.GasTipCap() overflow: %v", tx.GasTipCap()) + } + gasFeeCap, overflow := uint256.FromBig(tx.GasFeeCap()) + if overflow { + return nil, fmt.Errorf("tx.GasFeeCap() overflow: %v", tx.GasFeeCap()) + } + value, overflow := uint256.FromBig(tx.Value()) + if overflow { + return nil, fmt.Errorf("tx.Value() overflow: %v", tx.Value()) + } + blobFeeCap, overflow := uint256.FromBig(tx.BlobGasFeeCap()) + if overflow { + return nil, fmt.Errorf("tx.BlobGasFeeCap() overflow: %v", tx.BlobGasFeeCap()) + } + inner = &spanBatchBlobTxData{ + Value: value, + GasTipCap: gasTipCap, + GasFeeCap: gasFeeCap, + Data: tx.Data(), + AccessList: tx.AccessList(), + BlobFeeCap: blobFeeCap, + BlobHashes: tx.BlobHashes(), } case types.SetCodeTxType: inner = &spanBatchSetCodeTxData{

diff --git official optimism/op-node/rollup/derive/span_batch_txs.go SWC optimism/op-node/rollup/derive/span_batch_txs.go index 7c354430fc30e5a61f2fbbdcb36df607f311e677..159a9eb14506010fbc23980912d5bea288af0e15 100644 --- official optimism/op-node/rollup/derive/span_batch_txs.go +++ SWC optimism/op-node/rollup/derive/span_batch_txs.go @@ -271,6 +271,8 @@ case types.AccessListTxType: v = bit case types.DynamicFeeTxType: v = bit + case types.BlobTxType: + v = bit case types.SetCodeTxType: v = bit default: @@ -387,6 +389,8 @@ } case types.AccessListTxType: yParityBit = uint(v) case types.DynamicFeeTxType: + yParityBit = uint(v) + case types.BlobTxType: yParityBit = uint(v) case types.SetCodeTxType: yParityBit = uint(v)

diff --git official optimism/op-node/rollup/derive/span_batch_txs_test.go SWC optimism/op-node/rollup/derive/span_batch_txs_test.go index 1a752f75f47baab50442081154e40b49b048729f..7ccd1b2761a60a00ee5c533d837591d9c2f060e6 100644 --- official optimism/op-node/rollup/derive/span_batch_txs_test.go +++ SWC optimism/op-node/rollup/derive/span_batch_txs_test.go @@ -333,7 +333,8 @@ func TestSpanBatchTxsRecoverV(t *testing.T) { rng := rand.New(rand.NewSource(0x123))   chainID := big.NewInt(rng.Int63n(1000)) - isthmusSigner := types.NewIsthmusSigner(chainID) + isthmusSigner := types.NewIsthmusSigner(chainID, false) + cancunSigner := types.NewCancunSigner(chainID) totalblockTxCount := 20 + rng.Intn(100)   cases := []txTypeTest{ @@ -342,6 +343,7 @@ {"legacy tx", testutils.RandomLegacyTx, isthmusSigner}, {"access list tx", testutils.RandomAccessListTx, isthmusSigner}, {"dynamic fee tx", testutils.RandomDynamicFeeTx, isthmusSigner}, {"setcode tx", testutils.RandomSetCodeTx, isthmusSigner}, + {"blob tx", testutils.RandomBlobTx, cancunSigner}, }   for _, testCase := range cases { @@ -425,7 +427,7 @@ func TestSpanBatchTxsRoundTripFullTxs(t *testing.T) { rng := rand.New(rand.NewSource(0x13377331)) chainID := big.NewInt(rng.Int63n(1000)) - isthmusSigner := types.NewIsthmusSigner(chainID) + isthmusSigner := types.NewIsthmusSigner(chainID, false)   cases := []txTypeTest{ {"unprotected legacy tx", testutils.RandomLegacyTx, types.HomesteadSigner{}}, @@ -476,7 +478,7 @@ func TestSpanBatchTxsFullTxNotEnoughTxTos(t *testing.T) { rng := rand.New(rand.NewSource(0x13572468)) chainID := big.NewInt(rng.Int63n(1000)) - isthmusSigner := types.NewIsthmusSigner(chainID) + isthmusSigner := types.NewIsthmusSigner(chainID, false)   cases := []txTypeTest{ {"unprotected legacy tx", testutils.RandomLegacyTx, types.HomesteadSigner{}},

diff --git official optimism/op-node/rollup/driver/driver.go SWC optimism/op-node/rollup/driver/driver.go index cc402cecab8ac44860bf99b53d84446962e39632..c006dcd9529546bd00a2f157cd40acf41360ba65 100644 --- official optimism/op-node/rollup/driver/driver.go +++ SWC optimism/op-node/rollup/driver/driver.go @@ -48,6 +48,7 @@ syncCfg *sync.Config, sequencerConductor conductor.SequencerConductor, altDA AltDAIface, indexingMode bool, + dacClient engine.DACClient, ) *Driver { driverCtx, driverCancel := context.WithCancel(context.Background())   @@ -119,7 +120,7 @@ // Connect origin selector to the engine controller for force reset notifications ec.SetOriginSelectorResetter(findL1Origin)   sequencer = sequencing.NewSequencer(driverCtx, log, cfg, attrBuilder, findL1Origin, - sequencerStateListener, sequencerConductor, asyncGossiper, metrics, ec) + sequencerStateListener, sequencerConductor, asyncGossiper, metrics, ec, dacClient) sys.Register("sequencer", sequencer) } else { sequencer = sequencing.DisabledSequencer{}

diff --git official optimism/op-node/rollup/engine/engine_controller.go SWC optimism/op-node/rollup/engine/engine_controller.go index cca666a28a93754b83390f60a6455faed5ed5a39..3a6b871b741ffefc121010333870652d365d5084 100644 --- official optimism/op-node/rollup/engine/engine_controller.go +++ SWC optimism/op-node/rollup/engine/engine_controller.go @@ -92,6 +92,10 @@ OnCrossUnsafeUpdate(ctx context.Context, crossUnsafe eth.L2BlockRef, localUnsafe eth.L2BlockRef) OnCrossSafeUpdate(ctx context.Context, crossSafe eth.L2BlockRef, localSafe eth.L2BlockRef) }   +type DACClient interface { + UploadBlobs(context.Context, *eth.ExecutionPayloadEnvelope) error +} + type EngineController struct { engine ExecEngine // Underlying execution engine RPC log log.Logger

diff --git official optimism/op-node/rollup/sequencing/sequencer.go SWC optimism/op-node/rollup/sequencing/sequencer.go index c536c5bc8b276391260710ad1d88279ae35fc4fa..8887cc8cf73e04d0a232ba8c223c8ab0edfa6fcc 100644 --- official optimism/op-node/rollup/sequencing/sequencer.go +++ SWC optimism/op-node/rollup/sequencing/sequencer.go @@ -126,6 +126,8 @@ latestHeadSet chan struct{}   // toBlockRef converts a payload to a block-ref, and is only configurable for test-purposes toBlockRef func(rollupCfg *rollup.Config, payload *eth.ExecutionPayload) (eth.L2BlockRef, error) + + dacClient engine.DACClient }   var _ SequencerIface = (*Sequencer)(nil) @@ -138,6 +140,7 @@ conductor conductor.SequencerConductor, asyncGossip AsyncGossiper, metrics Metrics, eng attributes.EngineController, + dacClient engine.DACClient, ) *Sequencer { return &Sequencer{ ctx: driverCtx, @@ -153,6 +156,7 @@ metrics: metrics, eng: eng, timeNow: time.Now, toBlockRef: derive.PayloadToBlockRef, + dacClient: dacClient, } }   @@ -274,6 +278,28 @@ "block", x.Envelope.ExecutionPayload.ID(), "parent", x.Envelope.ExecutionPayload.ParentID(), "txs", len(x.Envelope.ExecutionPayload.Transactions), "time", uint64(x.Envelope.ExecutionPayload.Timestamp)) + + { + envelope := x.Envelope + if envelope.BlobsBundle != nil && len(envelope.BlobsBundle.Blobs) > 0 { + // Deriving is based on onchain-data which doesn't contain L2 blob. + if x.DerivedFrom != (eth.L1BlockRef{}) { + d.emitter.Emit(d.ctx, rollup.EngineTemporaryErrorEvent{ + Err: fmt.Errorf("got blobs when deriving")}) + return + } + if d.dacClient != nil { + ctx, cancel := context.WithTimeout(d.ctx, time.Second*5) + defer cancel() + err := d.dacClient.UploadBlobs(ctx, envelope) + if err != nil { + d.emitter.Emit(d.ctx, rollup.EngineTemporaryErrorEvent{ + Err: fmt.Errorf("UploadBlobs failed: %w", err)}) + return + } + } + } + }   // generous timeout, the conductor is important ctx, cancel := context.WithTimeout(d.ctx, time.Second*30)

diff --git official optimism/op-node/rollup/sequencing/sequencer_test.go SWC optimism/op-node/rollup/sequencing/sequencer_test.go index bcdd6cdd79060bb80afe9309007147469451cc30..2148ebd33e312a1362945159bf1d196a98e50dad 100644 --- official optimism/op-node/rollup/sequencing/sequencer_test.go +++ SWC optimism/op-node/rollup/sequencing/sequencer_test.go @@ -733,7 +733,7 @@ asyncGossip: &FakeAsyncGossip{}, } seq := NewSequencer(context.Background(), log, cfg, deps.attribBuilder, deps.l1OriginSelector, deps.seqState, deps.conductor, - deps.asyncGossip, metrics.NoopMetrics, fakeEngController{}) + deps.asyncGossip, metrics.NoopMetrics, fakeEngController{}, nil) // We create mock payloads, with the epoch-id as tx[0], rather than proper L1Block-info deposit tx. seq.toBlockRef = func(rollupCfg *rollup.Config, payload *eth.ExecutionPayload) (eth.L2BlockRef, error) { return eth.L2BlockRef{

diff --git official optimism/op-node/service.go SWC optimism/op-node/service.go index c87f61af6f74f5eb36bd328f0503cf92a9dc8a59..38380e05b4a22935f2a23b4cafe2f122533b696c 100644 --- official optimism/op-node/service.go +++ SWC optimism/op-node/service.go @@ -124,7 +124,8 @@ return conductorRPCEndpoint, nil }, ConductorRpcTimeout: ctx.Duration(flags.ConductorRpcTimeoutFlag.Name),   - AltDA: altda.ReadCLIConfig(ctx), + AltDA: altda.ReadCLIConfig(ctx), + DACConfig: config.ReadDACConfigFromCLI(ctx),   IgnoreMissingPectraBlobSchedule: ctx.Bool(flags.IgnoreMissingPectraBlobSchedule.Name), FetchWithdrawalRootFromState: ctx.Bool(flags.FetchWithdrawalRootFromState.Name),

diff --git official optimism/op-program/client/l2/engineapi/block_processor.go SWC optimism/op-program/client/l2/engineapi/block_processor.go index be7178b32ed0ed0d6bb79dd01bc32093ca8a4d1b..c4dbcaf44358bdd8772387ec54ad67fd855c9a8d 100644 --- official optimism/op-program/client/l2/engineapi/block_processor.go +++ SWC optimism/op-program/client/l2/engineapi/block_processor.go @@ -10,6 +10,7 @@ "github.com/ethereum-optimism/optimism/op-service/predeploys" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc/eip1559" + "github.com/ethereum/go-ethereum/consensus/misc/eip4844" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -105,7 +106,8 @@ if provider.Config().IsCancun(header.Number, header.Time) { // Blob tx not supported on optimism chains but fields must be set when Cancun is active. zero := uint64(0) header.BlobGasUsed = &zero - header.ExcessBlobGas = &zero + excessBlobGas := eip4844.CalcExcessBlobGas(provider.Config(), parentHeader, header.Time) + header.ExcessBlobGas = &excessBlobGas } // core.NewEVMBlockContext need to be called after the blob gas fields are set vmenv = mkEVM() @@ -153,6 +155,9 @@ return nil, fmt.Errorf("failed to apply transaction to L2 block (tx %d): %w", txIndex, err) } b.receipts = append(b.receipts, receipt) b.transactions = append(b.transactions, tx) + if b.header.BlobGasUsed != nil { + *b.header.BlobGasUsed += receipt.BlobGasUsed + } return receipt, nil }

diff --git official optimism/op-service/eth/types.go SWC optimism/op-service/eth/types.go index 8d192085de0739699e33faaa039cfe40bda922e9..aebacca74ff6d887329b8066da94349fa5c71300 100644 --- official optimism/op-service/eth/types.go +++ SWC optimism/op-service/eth/types.go @@ -231,8 +231,9 @@ Timestamp uint64 `json:"timestamp"` }   type ExecutionPayloadEnvelope struct { - ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot,omitempty"` - ExecutionPayload *ExecutionPayload `json:"executionPayload"` + ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot,omitempty"` + ExecutionPayload *ExecutionPayload `json:"executionPayload"` + BlobsBundle *engine.BlobsBundleV1 `json:"blobsBundle"` }   func (env *ExecutionPayloadEnvelope) ID() BlockID {

diff --git official optimism/op-service/sources/engine_client.go SWC optimism/op-service/sources/engine_client.go index c16629b77d2bbd040188d1b4f6cd6747b6bacbec..755bcf5a0070061d856c0c7e42af4e22f3d6adf9 100644 --- official optimism/op-service/sources/engine_client.go +++ SWC optimism/op-service/sources/engine_client.go @@ -107,6 +107,8 @@ switch method := s.evp.NewPayloadVersion(uint64(payload.Timestamp)); method { case eth.NewPayloadV4: err = s.RPC.CallContext(ctx, &result, string(method), payload, []common.Hash{}, parentBeaconBlockRoot, []hexutil.Bytes{}) case eth.NewPayloadV3: + // now we pass empty array to skip checking versionedHashes + // TODO: sync with OP upstream once they support L2 blob tx err = s.RPC.CallContext(ctx, &result, string(method), payload, []common.Hash{}, parentBeaconBlockRoot) case eth.NewPayloadV2: err = s.RPC.CallContext(ctx, &result, string(method), payload)

diff --git official optimism/op-service/testutils/random.go SWC optimism/op-service/testutils/random.go index e685b97c11b3947d73a25a3b714371e9e40ca6fe..87f50f666699c98931b575233d1373f56be453a9 100644 --- official optimism/op-service/testutils/random.go +++ SWC optimism/op-service/testutils/random.go @@ -144,7 +144,7 @@ return &to }   func isIsthmusSigner(signer types.Signer) bool { - isthusSigner := types.NewIsthmusSigner(signer.ChainID()) + isthusSigner := types.NewIsthmusSigner(signer.ChainID(), false) return signer.Equal(isthusSigner) }   @@ -253,6 +253,30 @@ baseFee := new(big.Int).SetUint64(rng.Uint64()) return RandomDynamicFeeTxWithBaseFee(rng, baseFee, signer) }   +func RandomBlobTx(rng *rand.Rand, signer types.Signer) *types.Transaction { + baseFee := new(big.Int).SetUint64(rng.Uint64()) + key := InsecureRandomKey(rng) + tip := big.NewInt(rng.Int63n(10 * params.GWei)) + txData := &types.BlobTx{ + ChainID: uint256.MustFromBig(signer.ChainID()), + Nonce: rng.Uint64(), + GasTipCap: uint256.MustFromBig(tip), + GasFeeCap: uint256.MustFromBig(new(big.Int).Add(baseFee, tip)), + Gas: params.TxGas + uint64(rng.Int63n(2_000_000)), + To: RandomAddress(rng), + Value: uint256.MustFromBig(RandomETH(rng, 10)), + Data: RandomData(rng, rng.Intn(1000)), + AccessList: nil, + BlobFeeCap: uint256.MustFromBig(baseFee), + BlobHashes: []common.Hash{RandomHash(rng)}, + } + tx, err := types.SignNewTx(key, signer, txData) + if err != nil { + panic(err) + } + return tx +} + func RandomSetCodeAuth(rng *rand.Rand) types.SetCodeAuthorization { key := InsecureRandomKey(rng)   @@ -360,7 +384,7 @@ if chainIDInt == 0 { // Zero chainID is invalid. chainIDInt++ } chainID := big.NewInt(chainIDInt) - signer := types.NewIsthmusSigner(chainID) + signer := types.NewIsthmusSigner(chainID, false) txs := make([]*types.Transaction, 0, txCount+len(ptxs)) txs = append(txs, ptxs...) for i := 0; i < txCount; i++ {

diff --git official optimism/op-node/bindings/l1block.go SWC optimism/op-node/bindings/l1block.go index 41a24ec38878128d02ced08b4b14abca2aa378e6..5793ce341edb0a499c698b9fbe84f3669ff9d499 100644 --- official optimism/op-node/bindings/l1block.go +++ SWC optimism/op-node/bindings/l1block.go @@ -30,8 +30,8 @@ )   // L1BlockMetaData contains all meta data concerning the L1Block contract. var L1BlockMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"DEPOSITOR_ACCOUNT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"baseFeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"basefee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"batcherHash\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blobBaseFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blobBaseFeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hash\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1FeeOverhead\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1FeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"number\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sequenceNumber\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setL1BlockValues\",\"inputs\":[{\"name\":\"_number\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"_timestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"_basefee\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_hash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_sequenceNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"_batcherHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_l1FeeOverhead\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_l1FeeScalar\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setL1BlockValuesEcotone\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"timestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"}]", - Bin: "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", + ABI: "[{\"type\":\"function\",\"name\":\"DEPOSITOR_ACCOUNT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"HISTORY_SIZE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"baseFeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"basefee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"batcherHash\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blobBaseFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blobBaseFeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blockHash\",\"inputs\":[{\"name\":\"_historyNumber\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hash\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"historyHashes\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1FeeOverhead\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1FeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"number\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sequenceNumber\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setL1BlockValues\",\"inputs\":[{\"name\":\"_number\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"_timestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"_basefee\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_hash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_sequenceNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"_batcherHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_l1FeeOverhead\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_l1FeeScalar\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setL1BlockValuesEcotone\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"timestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"}]", + Bin: "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", }   // L1BlockABI is the input ABI used to generate the binding from. @@ -232,6 +232,37 @@ func (_L1Block *L1BlockCallerSession) DEPOSITORACCOUNT() (common.Address, error) { return _L1Block.Contract.DEPOSITORACCOUNT(&_L1Block.CallOpts) }   +// HISTORYSIZE is a free data retrieval call binding the contract method 0x652c462e. +// +// Solidity: function HISTORY_SIZE() view returns(uint256) +func (_L1Block *L1BlockCaller) HISTORYSIZE(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _L1Block.contract.Call(opts, &out, "HISTORY_SIZE") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// HISTORYSIZE is a free data retrieval call binding the contract method 0x652c462e. +// +// Solidity: function HISTORY_SIZE() view returns(uint256) +func (_L1Block *L1BlockSession) HISTORYSIZE() (*big.Int, error) { + return _L1Block.Contract.HISTORYSIZE(&_L1Block.CallOpts) +} + +// HISTORYSIZE is a free data retrieval call binding the contract method 0x652c462e. +// +// Solidity: function HISTORY_SIZE() view returns(uint256) +func (_L1Block *L1BlockCallerSession) HISTORYSIZE() (*big.Int, error) { + return _L1Block.Contract.HISTORYSIZE(&_L1Block.CallOpts) +} + // BaseFeeScalar is a free data retrieval call binding the contract method 0xc5985918. // // Solidity: function baseFeeScalar() view returns(uint32) @@ -387,6 +418,37 @@ func (_L1Block *L1BlockCallerSession) BlobBaseFeeScalar() (uint32, error) { return _L1Block.Contract.BlobBaseFeeScalar(&_L1Block.CallOpts) }   +// BlockHash is a free data retrieval call binding the contract method 0x85df51fd. +// +// Solidity: function blockHash(uint256 _historyNumber) view returns(bytes32) +func (_L1Block *L1BlockCaller) BlockHash(opts *bind.CallOpts, _historyNumber *big.Int) ([32]byte, error) { + var out []interface{} + err := _L1Block.contract.Call(opts, &out, "blockHash", _historyNumber) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// BlockHash is a free data retrieval call binding the contract method 0x85df51fd. +// +// Solidity: function blockHash(uint256 _historyNumber) view returns(bytes32) +func (_L1Block *L1BlockSession) BlockHash(_historyNumber *big.Int) ([32]byte, error) { + return _L1Block.Contract.BlockHash(&_L1Block.CallOpts, _historyNumber) +} + +// BlockHash is a free data retrieval call binding the contract method 0x85df51fd. +// +// Solidity: function blockHash(uint256 _historyNumber) view returns(bytes32) +func (_L1Block *L1BlockCallerSession) BlockHash(_historyNumber *big.Int) ([32]byte, error) { + return _L1Block.Contract.BlockHash(&_L1Block.CallOpts, _historyNumber) +} + // Hash is a free data retrieval call binding the contract method 0x09bd5a60. // // Solidity: function hash() view returns(bytes32) @@ -416,6 +478,37 @@ // // Solidity: function hash() view returns(bytes32) func (_L1Block *L1BlockCallerSession) Hash() ([32]byte, error) { return _L1Block.Contract.Hash(&_L1Block.CallOpts) +} + +// HistoryHashes is a free data retrieval call binding the contract method 0x92abaa42. +// +// Solidity: function historyHashes(uint256 ) view returns(bytes32) +func (_L1Block *L1BlockCaller) HistoryHashes(opts *bind.CallOpts, arg0 *big.Int) ([32]byte, error) { + var out []interface{} + err := _L1Block.contract.Call(opts, &out, "historyHashes", arg0) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// HistoryHashes is a free data retrieval call binding the contract method 0x92abaa42. +// +// Solidity: function historyHashes(uint256 ) view returns(bytes32) +func (_L1Block *L1BlockSession) HistoryHashes(arg0 *big.Int) ([32]byte, error) { + return _L1Block.Contract.HistoryHashes(&_L1Block.CallOpts, arg0) +} + +// HistoryHashes is a free data retrieval call binding the contract method 0x92abaa42. +// +// Solidity: function historyHashes(uint256 ) view returns(bytes32) +func (_L1Block *L1BlockCallerSession) HistoryHashes(arg0 *big.Int) ([32]byte, error) { + return _L1Block.Contract.HistoryHashes(&_L1Block.CallOpts, arg0) }   // L1FeeOverhead is a free data retrieval call binding the contract method 0x8b239f73.

diff --git official optimism/packages/contracts-bedrock/interfaces/L2/IL1Block.sol SWC optimism/packages/contracts-bedrock/interfaces/L2/IL1Block.sol index 65b9ef0f2029b1eaad9e6547af2c8fd514d0885d..19024bbee5d68de0d4fbfebb5c442d22f45da41f 100644 --- official optimism/packages/contracts-bedrock/interfaces/L2/IL1Block.sol +++ SWC optimism/packages/contracts-bedrock/interfaces/L2/IL1Block.sol @@ -38,4 +38,7 @@ function timestamp() external view returns (uint64); function version() external pure returns (string memory);   function __constructor__() external; + + function historySize() external pure returns (uint256); + function blockHash(uint256 _historyNumber) external view returns (bytes32); }

diff --git official optimism/packages/contracts-bedrock/src/L2/L1Block.sol SWC optimism/packages/contracts-bedrock/src/L2/L1Block.sol index fffce12bb5115efcfd172aaeeb8a90f7e7396ae9..57fa2a10076bb152881211698770188277e30b81 100644 --- official optimism/packages/contracts-bedrock/src/L2/L1Block.sol +++ SWC optimism/packages/contracts-bedrock/src/L2/L1Block.sol @@ -95,6 +95,25 @@ function isCustomGasToken() public pure returns (bool is_) { is_ = false; }   + // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.L1Block.HistoryHashesStorage")) - 1)) & + // ~bytes32(uint256(0xff)) + bytes32 private constant _L1BLOCK_HISTORY_HASHES_LOCATION = + 0xb6e35d777715793a0808adb4ab3d51fc56065457feaf3a18bd958afef33bef00; + /// @notice size of historyHashes. + uint256 internal constant HISTORY_SIZE = 8192; + /// @custom:storage-location erc7201:openzeppelin.storage.L1Block.HistoryHashesStorage + + struct HistoryHashesStorage { + /// @notice The 8191 history L1 blockhashes and 1 latest L1 blockhash. + bytes32[HISTORY_SIZE] historyHashes; + } + + function _getHistoryHashesStorage() private pure returns (HistoryHashesStorage storage $) { + assembly { + $.slot := _L1BLOCK_HISTORY_HASHES_LOCATION + } + } + /// @custom:legacy /// @notice Updates the L1 block values. /// @param _number L1 blocknumber. @@ -158,6 +177,36 @@ sstore(blobBaseFee.slot, calldataload(68)) // uint256 sstore(hash.slot, calldataload(100)) // bytes32 sstore(batcherHash.slot, calldataload(132)) // bytes32 } + + HistoryHashesStorage storage $ = _getHistoryHashesStorage(); + $.historyHashes[number % HISTORY_SIZE] = hash; + } + + /// @notice Returns the L1 block hash at the requested L1 blocknumber. + /// Only the most recent 8191 L1 block hashes are available, excluding the current one. + /// @param _historyNumber L1 blocknumber. + function blockHash(uint256 _historyNumber) external view returns (bytes32) { + // translated from + // [opBlockhash](https://github.com/ethereum/go-ethereum/blob/e31709db6570e302557a9bccd681034ea0dcc246/core/vm/instructions.go#L434) + // with 256 => HISTORY_SIZE-1 + uint256 lower; + uint256 upper = number; + if (upper < HISTORY_SIZE) { + lower = 0; + } else { + lower = upper - HISTORY_SIZE + 1; + } + if (_historyNumber >= lower && _historyNumber < upper) { + HistoryHashesStorage storage $ = _getHistoryHashesStorage(); + return $.historyHashes[_historyNumber % HISTORY_SIZE]; + } else { + return bytes32(0); + } + } + + /// @notice Returns the size of history hashes. + function historySize() external pure returns (uint256) { + return HISTORY_SIZE; }   /// @notice Updates the L1 block values for an Isthmus upgraded chain.

diff --git official optimism/packages/contracts-bedrock/test/L2/L1Block.t.sol SWC optimism/packages/contracts-bedrock/test/L2/L1Block.t.sol index 8a7d22cae8de1b0b470134fcbf5cfe8ada7679e6..15a279d195caeaf7aaeeb948bb343e43862ab339 100644 --- official optimism/packages/contracts-bedrock/test/L2/L1Block.t.sol +++ SWC optimism/packages/contracts-bedrock/test/L2/L1Block.t.sol @@ -209,6 +209,62 @@ // make sure return value is the expected function selector for "NotDepositor()" bytes memory expReturn = hex"3cc50b45"; assertEq(data, expReturn); } + + /// @dev Tests that `blockHash` works for block range [n-256, n) where n is the latest + /// L1 block number known by the L2 system. + function testFuzz_blockHash_succeeds( + uint32 baseFeeScalar, + uint32 blobBaseFeeScalar, + uint64 sequenceNumber, + uint64 timestamp, + uint64 number, + uint256 baseFee, + uint256 blobBaseFee, + bytes32 hash, + bytes32 batcherHash + ) + external + { + if (number > type(uint64).max - uint64(l1Block.historySize()) - 1) { + number = type(uint64).max - uint64(l1Block.historySize()) - 1; + } + if (uint256(hash) > type(uint256).max - l1Block.historySize() - 1) { + hash = bytes32(type(uint256).max - l1Block.historySize() - 1); + } + + for (uint256 i = 1; i <= l1Block.historySize() + 1; i++) { + bytes memory functionCallDataPacked = Encoding.encodeSetL1BlockValuesEcotone( + baseFeeScalar, + blobBaseFeeScalar, + sequenceNumber, + timestamp, + number + uint64(i), + baseFee, + blobBaseFee, + bytes32(uint256(hash) + i), + batcherHash + ); + + vm.prank(depositor); + (bool success,) = address(l1Block).call(functionCallDataPacked); + assertTrue(success, "function call failed"); + + assertEq(l1Block.number(), number + uint64(i)); + assertEq(l1Block.hash(), bytes32(uint256(hash) + i)); + } + + assertTrue( + l1Block.blockHash(number + l1Block.historySize() + 1) == bytes32(0), + "should return bytes32(0) for the latest L1 block" + ); + assertTrue(l1Block.blockHash(number + 1) == bytes32(0), "should return bytes32(0) for blocks out of range"); + for (uint256 i = 2; i <= l1Block.historySize(); i++) { + assertTrue( + l1Block.blockHash(number + i) == bytes32(uint256(hash) + i), + "blockHash's return value should match the value set" + ); + } + } }   /// @title L1Block_SetL1BlockValuesIsthmus_Test

diff --git official optimism/packages/contracts-bedrock/interfaces/L1/IOptimismPortal2.sol SWC optimism/packages/contracts-bedrock/interfaces/L1/IOptimismPortal2.sol index 987450481d6b6f56eea6d12a65437123964357e8..f22191cff3d574872ca5173fa0371cf5fb0f2320 100644 --- official optimism/packages/contracts-bedrock/interfaces/L1/IOptimismPortal2.sol +++ SWC optimism/packages/contracts-bedrock/interfaces/L1/IOptimismPortal2.sol @@ -33,11 +33,16 @@ error OptimismPortal_NoReentrancy(); error OptimismPortal_ProofNotOldEnough(); error OptimismPortal_Unproven(); error OptimismPortal_InvalidLockboxState(); + error OptimismPortal_Unauthorized(); + error OptimismPortal_NativeDepositForbidden(); error OutOfGas(); error UnexpectedList(); error UnexpectedString();   event Initialized(uint8 version); + event NativeDepositEnabled(); + event NativeDepositDisabled(); + event MinterSet(address indexed minter); event TransactionDeposited(address indexed from, address indexed to, uint256 indexed version, bytes opaqueData); event WithdrawalFinalized(bytes32 indexed withdrawalHash, bool success); event WithdrawalProven(bytes32 indexed withdrawalHash, address indexed from, address indexed to); @@ -101,6 +106,10 @@ function respectedGameType() external view returns (GameType); function respectedGameTypeUpdatedAt() external view returns (uint64); function systemConfig() external view returns (ISystemConfig); function version() external pure returns (string memory); + + function setMinter(address _minter) external; + function mintTransaction(address _to, uint256 _value) external; + function setNativeDeposit(bool _disable) external;   function __constructor__(uint256 _proofMaturityDelaySeconds) external; }

diff --git official optimism/packages/contracts-bedrock/interfaces/L2/IL2ToL1MessagePasser.sol SWC optimism/packages/contracts-bedrock/interfaces/L2/IL2ToL1MessagePasser.sol index 4629dbaba8d09fcacb9ba8b369ec1e2716a0b51b..7526983ea28dc7b7dd352a79692b15c17bd40d88 100644 --- official optimism/packages/contracts-bedrock/interfaces/L2/IL2ToL1MessagePasser.sol +++ SWC optimism/packages/contracts-bedrock/interfaces/L2/IL2ToL1MessagePasser.sol @@ -2,6 +2,10 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0;   interface IL2ToL1MessagePasser { + event NativeDepositEnabled(); + event NativeDepositDisabled(); + error L2ToL1MessagePasser_NativeDepositDisabled(); + event MessagePassed( uint256 indexed nonce, address indexed sender, @@ -21,6 +25,7 @@ function initiateWithdrawal(address _target, uint256 _gasLimit, bytes memory _data) external payable; function messageNonce() external view returns (uint256); function sentMessages(bytes32) external view returns (bool); function version() external view returns (string memory); + function setNativeDeposit(bool _disable) external;   function __constructor__() external; }

diff --git official optimism/packages/contracts-bedrock/src/L1/OptimismPortal2.sol SWC optimism/packages/contracts-bedrock/src/L1/OptimismPortal2.sol index 071bf55a8892230103bbcf552105b0ac6431f585..50b1d35e407da4bf2cff405051e4fd7c90a18b7b 100644 --- official optimism/packages/contracts-bedrock/src/L1/OptimismPortal2.sol +++ SWC optimism/packages/contracts-bedrock/src/L1/OptimismPortal2.sol @@ -11,6 +11,7 @@ // Libraries import { EOA } from "src/libraries/EOA.sol"; import { SafeCall } from "src/libraries/SafeCall.sol"; import { Constants } from "src/libraries/Constants.sol"; +import { Predeploys } from "src/libraries/Predeploys.sol"; import { Types } from "src/libraries/Types.sol"; import { Hashing } from "src/libraries/Hashing.sol"; import { SecureMerkleTrie } from "src/libraries/trie/SecureMerkleTrie.sol"; @@ -24,6 +25,7 @@ import { ISystemConfig } from "interfaces/L1/ISystemConfig.sol"; import { IResourceMetering } from "interfaces/L1/IResourceMetering.sol"; import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol"; import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; +import { IL2ToL1MessagePasser } from "interfaces/L2/IL2ToL1MessagePasser.sol"; import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol"; import { IETHLockbox } from "interfaces/L1/IETHLockbox.sol"; import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; @@ -50,6 +52,9 @@ uint256 internal constant DEPOSIT_VERSION = 0;   /// @notice The L2 gas limit set when eth is deposited using the receive() function. uint64 internal constant RECEIVE_DEFAULT_GAS_LIMIT = 100_000; + + /// @notice The L2 gas limit for system deposit transactions that are initiated from L1. + uint32 internal constant SYSTEM_DEPOSIT_GAS_LIMIT = 200_000;   /// @notice Address of the L2 account which initiated a withdrawal in this transaction. /// If the value of this variable is the default L2 sender address, then we are NOT @@ -130,6 +135,24 @@ /// @custom:legacy /// @custom:spacer superRootsActive bool private spacer_63_20_1;   + // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.OptimismPortal2.QKCConfigStorage")) - 1)) & + // ~bytes32(uint256(0xff)) + bytes32 private constant _QKC_CONFIG_STORAGE_LOCATION = + 0xb42b8bfdf1143b9dfcdc891f15a039d3c36301d501f5a44f62223d852a602a00; + /// @custom:storage-location erc7201:openzeppelin.storage.OptimismPortal2.QKCConfigStorage + + struct QKCConfigStorage { + /// @notice The minter for migrating existing L1 token to L2 native token. + address minter; + bool disableNativeDeposit; + } + + function _getQKCConfigStorage() private pure returns (QKCConfigStorage storage $) { + assembly { + $.slot := _QKC_CONFIG_STORAGE_LOCATION + } + } + /// @notice Emitted when a transaction is deposited from L1 to L2. The parameters of this event /// are read by the rollup node and used to derive deposit transactions on L2. /// @param from Address that triggered the deposit transaction. @@ -156,6 +179,18 @@ /// @param withdrawalHash Hash of the withdrawal transaction. /// @param success Whether the withdrawal transaction was successful. event WithdrawalFinalized(bytes32 indexed withdrawalHash, bool success);   + /// QKC changes: + + /// @notice added back by QKC + error OptimismPortal_Unauthorized(); + /// @notice Emitted when a minter is set. + + event MinterSet(address indexed minter); + /// @notice Emitted when native deposit is disabled. + event NativeDepositDisabled(); + /// @notice Emitted when native deposit is enabled. + event NativeDepositEnabled(); + /// @notice Thrown when a withdrawal has already been finalized. error OptimismPortal_AlreadyFinalized();   @@ -173,6 +208,10 @@ error OptimismPortal_GasEstimation();   /// @notice Thrown when the gas limit for a deposit is too low. error OptimismPortal_GasLimitTooLow(); + + // @notice Thrown when native token is deposited to the portal contract when disabled. + // For swc, the native token is actually qkc so we need to disable ETH deposits. + error OptimismPortal_NativeDepositForbidden();   /// @notice Thrown when the target of a withdrawal is not a proper dispute game. error OptimismPortal_ImproperDisputeGame(); @@ -538,6 +577,66 @@ revert OptimismPortal_InvalidRootClaim(); } }   + /// @notice Add a minter to the OptimismPortal contract. To disable, set an empty value. + function setMinter(address _minter) external { + if (msg.sender != proxyAdminOwner()) { + revert OptimismPortal_Unauthorized(); + } + QKCConfigStorage storage $ = _getQKCConfigStorage(); + $.minter = _minter; + emit MinterSet(_minter); + } + + /// @notice Mint a specific amount of L2 native token to an address. + function mintTransaction(address _to, uint256 _value) external metered(RECEIVE_DEFAULT_GAS_LIMIT) { + QKCConfigStorage storage $ = _getQKCConfigStorage(); + if (msg.sender != $.minter) { + revert OptimismPortal_Unauthorized(); + } + + if (_to == address(0)) { + revert OptimismPortal_BadTarget(); + } + // Compute the opaque data that will be emitted as part of the TransactionDeposited event. + // We use opaque data so that we can update the TransactionDeposited event in the future + // without breaking the current interface. + bytes memory opaqueData = abi.encodePacked(_value, _value, RECEIVE_DEFAULT_GAS_LIMIT, false, bytes("")); + + // Emit a TransactionDeposited event so that the rollup node can derive a deposit + // transaction for this deposit. + emit TransactionDeposited(Constants.QKC_DEPOSITOR_ACCOUNT, _to, DEPOSIT_VERSION, opaqueData); + } + + /// @notice set native deposit flag. Pass true to disable. + function setNativeDeposit(bool _disable) external { + if (msg.sender != proxyAdminOwner()) { + revert OptimismPortal_Unauthorized(); + } + QKCConfigStorage storage $ = _getQKCConfigStorage(); + $.disableNativeDeposit = _disable; + if (_disable) { + emit NativeDepositDisabled(); + } else { + emit NativeDepositEnabled(); + } + + // Compute the opaque data that will be emitted as part of the TransactionDeposited event. + // We use opaque data so that we can update the TransactionDeposited event in the future + // without breaking the current interface. + bytes memory opaqueData = abi.encodePacked( + uint256(0), + uint256(0), + uint64(SYSTEM_DEPOSIT_GAS_LIMIT), + false, + abi.encodeCall(IL2ToL1MessagePasser.setNativeDeposit, (_disable)) + ); + // Emit a TransactionDeposited event so that the rollup node can derive a deposit + // transaction for this deposit. + emit TransactionDeposited( + Constants.QKC_DEPOSITOR_ACCOUNT, Predeploys.L2_TO_L1_MESSAGE_PASSER, DEPOSIT_VERSION, opaqueData + ); + } + /// @notice Accepts deposits of ETH and data, and emits a TransactionDeposited event for use in /// deriving deposit transactions. Note that if a deposit is made by a contract, its /// address will be aliased when retrieved using `tx.origin` or `msg.sender`. Consider @@ -560,6 +659,12 @@ public payable metered(_gasLimit) { + if (msg.value > 0) { + QKCConfigStorage storage $ = _getQKCConfigStorage(); + if ($.disableNativeDeposit) { + revert OptimismPortal_NativeDepositForbidden(); + } + } // If using ETHLockbox, lock the ETH in the ETHLockbox. if (_isUsingLockbox()) { if (msg.value > 0) ethLockbox.lockETH{ value: msg.value }();

diff --git official optimism/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol SWC optimism/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol index b25a2a1248bc5ce4570284f841b0b86776d4b433..3908f6de3a6de8efe658ac9291bcb4066f503913 100644 --- official optimism/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol +++ SWC optimism/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol @@ -6,6 +6,7 @@ import { Types } from "src/libraries/Types.sol"; import { Hashing } from "src/libraries/Hashing.sol"; import { Encoding } from "src/libraries/Encoding.sol"; import { Burn } from "src/libraries/Burn.sol"; +import { Constants } from "src/libraries/Constants.sol";   // Interfaces import { ISemver } from "interfaces/universal/ISemver.sol"; @@ -29,6 +30,22 @@ /// @notice A unique value hashed with each withdrawal. uint240 internal msgNonce;   + // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.L2ToL1MessagePasser.QKCConfigStorage")) - 1)) & + // ~bytes32(uint256(0xff)) + bytes32 private constant _QKC_CONFIG_STORAGE_LOCATION = + 0x750f1ab2ed0ba2a4405b31f7b30e394ba3545975e71082ba3e508022a159f900; + /// @custom:storage-location erc7201:openzeppelin.storage.L2ToL1MessagePasser.QKCConfigStorage + + struct QKCConfigStorage { + bool disableNativeDeposit; + } + + function _getQKCConfigStorage() private pure returns (QKCConfigStorage storage $) { + assembly { + $.slot := _QKC_CONFIG_STORAGE_LOCATION + } + } + /// @notice Emitted any time a withdrawal is initiated. /// @param nonce Unique value corresponding to each withdrawal. /// @param sender The L2 account address which initiated the withdrawal. @@ -51,6 +68,14 @@ /// @notice Emitted when the balance of this contract is burned. /// @param amount Amount of ETh that was burned. event WithdrawerBalanceBurnt(uint256 indexed amount);   + /// @notice Emitted when native deposit is disabled. + event NativeDepositDisabled(); + /// @notice Emitted when native deposit is enabled. + event NativeDepositEnabled(); + + /// @notice Error for disabled native deposit/withdraw. + error L2ToL1MessagePasser_NativeDepositDisabled(); + /// @custom:semver 1.1.2 string public constant version = "1.1.2";   @@ -74,6 +99,10 @@ /// @param _target Address to call on L1 execution. /// @param _gasLimit Minimum gas limit for executing the message on L1. /// @param _data Data to forward to L1 target. function initiateWithdrawal(address _target, uint256 _gasLimit, bytes memory _data) public payable { + QKCConfigStorage storage $ = _getQKCConfigStorage(); + if ($.disableNativeDeposit && msg.value > 0) { + revert L2ToL1MessagePasser_NativeDepositDisabled(); + } bytes32 withdrawalHash = Hashing.hashWithdrawal( Types.WithdrawalTransaction({ nonce: messageNonce(), @@ -100,5 +129,19 @@ /// different structures. /// @return Nonce of the next message to be sent, with added message version. function messageNonce() public view returns (uint256) { return Encoding.encodeVersionedNonce(msgNonce, MESSAGE_VERSION); + } + + /// @notice set native deposit flag. Pass true to disable. + function setNativeDeposit(bool _disable) external { + if (msg.sender != Constants.QKC_DEPOSITOR_ACCOUNT) { + revert("L2ToL1MessagePasser: Only the depositor #2 can enable/disable native deposits"); + } + QKCConfigStorage storage $ = _getQKCConfigStorage(); + $.disableNativeDeposit = _disable; + if (_disable) { + emit NativeDepositDisabled(); + } else { + emit NativeDepositEnabled(); + } } }

diff --git official optimism/packages/contracts-bedrock/src/libraries/Constants.sol SWC optimism/packages/contracts-bedrock/src/libraries/Constants.sol index 50ad716697486e11a6d802db9a5b9f53e7991a99..f0c5d085205e6cadec511952b82ce38d3f89f752 100644 --- official optimism/packages/contracts-bedrock/src/libraries/Constants.sol +++ SWC optimism/packages/contracts-bedrock/src/libraries/Constants.sol @@ -41,6 +41,8 @@ /// @notice The address that represents the system caller responsible for L1 attributes /// transactions. address internal constant DEPOSITOR_ACCOUNT = 0xDeaDDEaDDeAdDeAdDEAdDEaddeAddEAdDEAd0001; + /// @notice Another fixed address to avoid potential risky calls for deposit tx on L2. + address internal constant QKC_DEPOSITOR_ACCOUNT = 0xDEAdDeaddEAdDeadDEaddeAdDeaddEAd00514b43;   /// @notice Returns the default values for the ResourceConfig. These are the recommended values /// for a production network.

diff --git official optimism/op-program/Makefile SWC optimism/op-program/Makefile index e12c8e5a1d3b7f75a60c32bdb9826932f795e840..5f27a9af07141a8d53eb4ff2f020f1ba1bcab646 100644 --- official optimism/op-program/Makefile +++ SWC optimism/op-program/Makefile @@ -74,6 +74,10 @@ test: go test -v ./...   + +verify-beta-testnet: op-program-host op-program-client + env GO111MODULE=on go run ./verify/beta-testnet/cmd/beta-testnet.go --l1 $$SEPOLIA_L1URL --l1.beacon $$SEPOLIA_BEACON_URL --l2 $$SEPOLIA_L2URL --datadir /tmp/test-beta-testnet + capture-mainnet-genesis: op-program-host op-program-client rm -rf "$(COMPAT_DIR)/mainnet-genesis" "$(COMPAT_DIR)/mainnet-genesis.tar.bz" env GO111MODULE=on go run ./verify/mainnet/cmd/mainnet.go --l1 $$MAINNET_L1URL --l1.beacon $$MAINNET_BEACON_URL --l2 $$MAINNET_L2URL --datadir "$(COMPAT_DIR)/mainnet-genesis" --l1.head "0x4903424f6cc2cfba7c2bf8c8f48ca46721c963fa64b411cfee3697b781e3e5f1" --l2.start "105235063" --l2.end "105235064"

diff --git official optimism/op-program/scripts/build-prestates.sh SWC optimism/op-program/scripts/build-prestates.sh index aa77ae0be5ded669665d35776d44bca34f9cffad..ce098f583e67a5ea98ef3cb8bc30e78b49b0e582 100755 --- official optimism/op-program/scripts/build-prestates.sh +++ SWC optimism/op-program/scripts/build-prestates.sh @@ -12,7 +12,7 @@ cd "${TMP_DIR}"   # Need to check out a fresh copy of the monorepo so we can switch to specific tags without it also affecting the # contents of this script (which is checked into the repo). -git clone https://github.com/ethereum-optimism/optimism --recurse-submodules +git clone https://github.com/ethstorage/optimism --recurse-submodules   STATES_DIR="${SCRIPTS_DIR}/../temp/states" LOGS_DIR="${SCRIPTS_DIR}/../temp/logs"

diff --git official optimism/op-program/verify/beta-testnet/cmd/beta-testnet.go SWC optimism/op-program/verify/beta-testnet/cmd/beta-testnet.go new file mode 100644 index 0000000000000000000000000000000000000000..79fdda66394c34e8a8650ee11b10f10937de6fac --- /dev/null +++ SWC optimism/op-program/verify/beta-testnet/cmd/beta-testnet.go @@ -0,0 +1,68 @@ +package main + +import ( + "context" + "flag" + "fmt" + "os" + + "github.com/ethereum-optimism/optimism/op-program/verify" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum/go-ethereum/common" +) + +func main() { + var l1RpcUrl string + var l1RpcKind string + var l1BeaconUrl string + var l2RpcUrl string + var dataDir string + var l1HashStr string + var l2Start uint64 + var l2End uint64 + flag.StringVar(&l1RpcUrl, "l1", "", "L1 RPC URL to use") + flag.StringVar(&l1BeaconUrl, "l1.beacon", "", "L1 Beacon URL to use") + flag.StringVar(&l1RpcKind, "l1-rpckind", "", "L1 RPC kind") + flag.StringVar(&l2RpcUrl, "l2", "", "L2 RPC URL to use") + flag.StringVar(&dataDir, "datadir", "", + "Directory to use for storing pre-images. If not set a temporary directory will be used.") + flag.StringVar(&l1HashStr, "l1.head", "", "Hash of L1 block to use") + flag.Uint64Var(&l2Start, "l2.start", 0, "Block number of agreed L2 block") + flag.Uint64Var(&l2End, "l2.end", 0, "Block number of claimed L2 block") + flag.Parse() + + if l1RpcUrl == "" { + _, _ = fmt.Fprintln(os.Stderr, "Must specify --l1 RPC URL") + os.Exit(2) + } + if l1BeaconUrl == "" { + _, _ = fmt.Fprintln(os.Stderr, "Must specify --l1.beacon URL") + os.Exit(2) + } + if l2RpcUrl == "" { + _, _ = fmt.Fprintln(os.Stderr, "Must specify --l2 RPC URL") + os.Exit(2) + } + + // Apply the custom configs by running op-program + runner, err := verify.NewRunner(l1RpcUrl, l1RpcKind, l1BeaconUrl, l2RpcUrl, dataDir, "3335", eth.ChainIDFromUInt64(3335), false) + if err != nil { + _, _ = fmt.Fprintf(os.Stderr, "Failed to create runner: %v\n", err.Error()) + os.Exit(1) + } + + if l1HashStr == "" && l2Start == 0 && l2End == 0 { + err = runner.RunToFinalized(context.Background()) + } else { + l1Hash := common.HexToHash(l1HashStr) + if l1Hash == (common.Hash{}) { + _, _ = fmt.Fprintf(os.Stderr, "Invalid --l1.head: %v\n", l1HashStr) + os.Exit(2) + } + err = runner.RunBetweenBlocks(context.Background(), l1Hash, l2Start, l2End) + } + if err != nil { + _, _ = fmt.Fprintf(os.Stderr, "Failed: %v\n", err.Error()) + os.Exit(1) + } +}

diff --git official optimism/.gitmodules SWC optimism/.gitmodules index 1591d79b2a8af7c1865e8ae49e8f10709b1e0462..c80d071a1d4d7a9ea3ef5d569d0308da88c309eb 100644 --- official optimism/.gitmodules +++ SWC optimism/.gitmodules @@ -29,6 +29,13 @@ url = https://github.com/OpenZeppelin/openzeppelin-contracts [submodule "packages/contracts-bedrock/lib/solady-v0.0.245"] path = packages/contracts-bedrock/lib/solady-v0.0.245 url = https://github.com/vectorized/solady +[submodule "da-server"] + path = da-server + url = https://github.com/ethstorage/da-server [submodule "packages/contracts-bedrock/lib/superchain-registry"] path = packages/contracts-bedrock/lib/superchain-registry url = https://github.com/ethereum-optimism/superchain-registry +[submodule "op-geth"] + path = op-geth + url = https://github.com/QuarkChain/op-geth + branch = op-es

diff --git official optimism/.semgrep/rules/sol-rules.yaml SWC optimism/.semgrep/rules/sol-rules.yaml index bcd5616170a5c9995d0fd027fcce0bb25cbf1097..31cacaf334ee067f9ead4856cd636db7787aee38 100644 --- official optimism/.semgrep/rules/sol-rules.yaml +++ SWC optimism/.semgrep/rules/sol-rules.yaml @@ -324,6 +324,7 @@ - packages/contracts-bedrock/src/L1/OptimismPortalInterop.sol - packages/contracts-bedrock/src/L2/FeeVault.sol - packages/contracts-bedrock/src/L2/OptimismMintableERC721.sol - packages/contracts-bedrock/src/L2/OptimismMintableERC721Factory.sol + - packages/contracts-bedrock/src/L2/SoulGasToken.sol - packages/contracts-bedrock/src/cannon/MIPS64.sol - packages/contracts-bedrock/src/cannon/PreimageOracle.sol - packages/contracts-bedrock/src/dispute/AnchorStateRegistry.sol @@ -338,7 +339,6 @@ - packages/contracts-bedrock/src/governance/MintManager.sol - packages/contracts-bedrock/src/periphery/TransferOnion.sol - packages/contracts-bedrock/src/periphery/faucet/Faucet.sol - packages/contracts-bedrock/src/periphery/faucet/authmodules/AdminFaucetAuthModule.sol - - packages/contracts-bedrock/src/safe/DeputyGuardianModule.sol - packages/contracts-bedrock/src/safe/DeputyPauseModule.sol - packages/contracts-bedrock/src/safe/LivenessGuard.sol - packages/contracts-bedrock/src/safe/LivenessModule.sol

diff --git official optimism/Makefile SWC optimism/Makefile index a05239f14c354e9db134beef567308a2ee751e6f..9b83651f98698bf83ca66ede02fd9d85392224ee 100644 --- official optimism/Makefile +++ SWC optimism/Makefile @@ -257,11 +257,15 @@ export ENABLE_ANVIL=true && \ export PARALLEL=$$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4) endef   +# QKC: The following are removed to use environment variables for RPC URLs in CircleCI +# export SEPOLIA_RPC_URL="https://ci-sepolia-l1-archive.optimism.io" && \ +# export MAINNET_RPC_URL="https://ci-mainnet-l1-archive.optimism.io" && \ + # Additional CI-specific environment variables define CI_ENV_VARS export OP_TESTLOG_FILE_LOGGER_OUTDIR=$$(realpath ./tmp/testlogs) && \ -export SEPOLIA_RPC_URL="https://ci-sepolia-l1-archive.optimism.io" && \ -export MAINNET_RPC_URL="https://ci-mainnet-l1-archive.optimism.io" && \ +if [ -z "$$SEPOLIA_RPC_URL" ]; then echo "ERROR: SEPOLIA_RPC_URL is not set"; exit 1; fi && \ +if [ -z "$$MAINNET_RPC_URL" ]; then echo "ERROR: MAINNET_RPC_URL is not set"; exit 1; fi && \ export NAT_INTEROP_LOADTEST_TARGET=10 && \ export NAT_INTEROP_LOADTEST_TIMEOUT=30s endef

diff --git official optimism/devnet-sdk/system/txprocessor.go SWC optimism/devnet-sdk/system/txprocessor.go index 1279aadffc1b6e289c4a6d57cc5bb6a0abcf95e4..0d5f9c40a5feabc18a42cb6b8d8044025feb86e3 100644 --- official optimism/devnet-sdk/system/txprocessor.go +++ SWC optimism/devnet-sdk/system/txprocessor.go @@ -45,7 +45,7 @@ var signer types.Signer switch tx.Type() { case types.SetCodeTxType: - signer = types.NewIsthmusSigner(p.chainID) + signer = types.NewIsthmusSigner(p.chainID, false) case types.DynamicFeeTxType: signer = types.NewLondonSigner(p.chainID) case types.AccessListTxType:

diff --git official optimism/devnet-sdk/system/wallet.go SWC optimism/devnet-sdk/system/wallet.go index 147aea26d470f16bde1c627e79b6cf8c7737faa3..1851fd3893a98320b21b7a60fd7d2c18777eea2f 100644 --- official optimism/devnet-sdk/system/wallet.go +++ SWC optimism/devnet-sdk/system/wallet.go @@ -284,7 +284,7 @@ var signer coreTypes.Signer switch tx.Type() { case coreTypes.SetCodeTxType: - signer = coreTypes.NewIsthmusSigner(w.chain.ID()) + signer = coreTypes.NewIsthmusSigner(w.chain.ID(), false) case coreTypes.DynamicFeeTxType: signer = coreTypes.NewLondonSigner(w.chain.ID()) case coreTypes.AccessListTxType:

diff --git official optimism/kurtosis-devnet/optimism-package-trampoline/kurtosis.yml SWC optimism/kurtosis-devnet/optimism-package-trampoline/kurtosis.yml index 06e9db8afd93d243f1a50e36ebe254b20846c6d8..58f2cc557a9f554f3ad178f520e17666fc11e42e 100644 --- official optimism/kurtosis-devnet/optimism-package-trampoline/kurtosis.yml +++ SWC optimism/kurtosis-devnet/optimism-package-trampoline/kurtosis.yml @@ -2,7 +2,7 @@ name: github.com/ethereum-optimism/optimism/kurtosis-devnet/optimism-package-trampoline description: |- A trampoline package for optimism-package. This one is reproducible, due to the replace directives below. replace: - github.com/ethpandaops/optimism-package: github.com/ethpandaops/optimism-package@89e0b8cacab9f7e9f74d53b72d4870092825d577 + github.com/QuarkChain/optimism-package: github.com/QuarkChain/optimism-package@9553f5f6a70068139d1709b77665314c5ebbb78e github.com/ethpandaops/ethereum-package: github.com/ethpandaops/ethereum-package@83830d44823767af65eda7dfe6b26c87c536c4cf github.com/kurtosis-tech/prometheus-package: github.com/kurtosis-tech/prometheus-package@637c9dea933be18e47f96cadc0d9bb0e3a5aa9d6 # v1.0.0 github.com/kurtosis-tech/postgres-package: github.com/kurtosis-tech/postgres-package@9cbdde2c55e8d1656deb87821465a2ad244d8b33 # v1.0.0

diff --git official optimism/kurtosis-devnet/optimism-package-trampoline/main.star SWC optimism/kurtosis-devnet/optimism-package-trampoline/main.star index d1b2d34b0331ff62fd68ac85443bc21824454ab5..626771cda5d112e1b57923dc5968893579bad0d2 100644 --- official optimism/kurtosis-devnet/optimism-package-trampoline/main.star +++ SWC optimism/kurtosis-devnet/optimism-package-trampoline/main.star @@ -1,4 +1,4 @@ -optimism_package = import_module("github.com/ethpandaops/optimism-package/main.star") +optimism_package = import_module("github.com/QuarkChain/optimism-package/main.star")   def run(plan, args): # just delegate to optimism-package

diff --git official optimism/kurtosis-devnet/simple.yaml SWC optimism/kurtosis-devnet/simple.yaml index 351ac0230ac5c18ee3deed94d7c90171caa09747..6c7836f62b986af71ea89c77a4bb76c2e3f79d7c 100644 --- official optimism/kurtosis-devnet/simple.yaml +++ SWC optimism/kurtosis-devnet/simple.yaml @@ -22,6 +22,7 @@ max_mem: 0 cl: type: op-node image: {{ localDockerImage "op-node" }} + is_qkc: true log_level: "" extra_env_vars: {} extra_labels: {} @@ -66,6 +67,10 @@ l1_artifacts_locator: {{ localContractArtifacts "l1" }} l2_artifacts_locator: {{ localContractArtifacts "l2" }} overrides: faultGameAbsolutePrestate: {{ localPrestate.Hashes.prestate_mt64 }} + deploySoulGasToken: true + soulGasTokenTimeOffset: "0x0" + isSoulBackedByNative: true + l2GenesisBlobTimeOffset: "0x0" global_log_level: "info" global_node_selectors: {} global_tolerations: []

diff --git official optimism/mise.toml SWC optimism/mise.toml index be52c50066e561e9d9325e74c38a2c532fda8111..7d75b84e95d9831cbbcd25e7f9ddd640755a251a 100644 --- official optimism/mise.toml +++ SWC optimism/mise.toml @@ -37,7 +37,7 @@ # Other dependencies codecov-uploader = "0.8.0" goreleaser-pro = "2.11.2" -kurtosis = "1.8.1" +kurtosis = "1.11.1" op-acceptor = "op-acceptor/v3.6.1"   # Fake dependencies

diff --git official optimism/op-acceptance-tests/tests/fjord/check_scripts_test.go SWC optimism/op-acceptance-tests/tests/fjord/check_scripts_test.go index 2572332b7df7cf5c6fa5ce767240c08619eb8552..a9fe15fe1a126aa1d0b14955b754500ab76cdf26 100644 --- official optimism/op-acceptance-tests/tests/fjord/check_scripts_test.go +++ SWC optimism/op-acceptance-tests/tests/fjord/check_scripts_test.go @@ -162,12 +162,15 @@ gpoFee, err := dsl.ReadGasPriceOracleL1FeeAt(ctx, l2Client, gasPriceOracle, txUnsigned, receipt.BlockHash) require.NoError(err)   + baseFeeScalarMultiplierBig := common.Big1 + blobBaseFeeScalarMultiplierBig := common.Big1 + fastLzSize := uint64(types.FlzCompressLen(txUnsigned) + 68) - gethGPOFee, err := dsl.CalculateFjordL1Cost(ctx, l2Client, types.RollupCostData{FastLzSize: fastLzSize}, receipt.BlockHash) + gethGPOFee, err := dsl.CalculateFjordL1Cost(ctx, l2Client, types.RollupCostData{FastLzSize: fastLzSize}, receipt.BlockHash, baseFeeScalarMultiplierBig, blobBaseFeeScalarMultiplierBig) require.NoError(err) require.Equalf(gethGPOFee.Uint64(), gpoFee.Uint64(), "GPO L1 fee mismatch (expected=%d actual=%d)", gethGPOFee.Uint64(), gpoFee.Uint64())   - expectedFee, err := dsl.CalculateFjordL1Cost(ctx, l2Client, signedTx.RollupCostData(), receipt.BlockHash) + expectedFee, err := dsl.CalculateFjordL1Cost(ctx, l2Client, signedTx.RollupCostData(), receipt.BlockHash, baseFeeScalarMultiplierBig, blobBaseFeeScalarMultiplierBig) require.NoError(err) require.NotNil(receipt.L1Fee) dsl.ValidateL1FeeMatches(t, expectedFee, receipt.L1Fee) @@ -176,7 +179,7 @@ upperBound, err := dsl.ReadGasPriceOracleL1FeeUpperBoundAt(ctx, l2Client, gasPriceOracle, len(txUnsigned), receipt.BlockHash) require.NoError(err) txLenGPO := len(txUnsigned) + 68 flzUpperBound := uint64(txLenGPO + txLenGPO/255 + 16) - upperBoundCost, err := dsl.CalculateFjordL1Cost(ctx, l2Client, types.RollupCostData{FastLzSize: flzUpperBound}, receipt.BlockHash) + upperBoundCost, err := dsl.CalculateFjordL1Cost(ctx, l2Client, types.RollupCostData{FastLzSize: flzUpperBound}, receipt.BlockHash, baseFeeScalarMultiplierBig, blobBaseFeeScalarMultiplierBig) require.NoError(err) require.Equalf(upperBoundCost.Uint64(), upperBound.Uint64(), "GPO L1 upper bound mismatch (expected=%d actual=%d)", upperBoundCost.Uint64(), upperBound.Uint64())

diff --git official optimism/op-chain-ops/cmd/check-derivation/main.go SWC optimism/op-chain-ops/cmd/check-derivation/main.go index 026e821c01effaf7d4764c44636590b7a836927b..6ce6a3ce9801ca1d5ac8b8bebcdf9da5aaebb52c 100644 --- official optimism/op-chain-ops/cmd/check-derivation/main.go +++ SWC optimism/op-chain-ops/cmd/check-derivation/main.go @@ -302,7 +302,7 @@ }   tx := types.NewTx(txData)   - signer := types.NewIsthmusSigner(chainId) + signer := types.NewIsthmusSigner(chainId, false) if !protected { if txType == types.LegacyTxType { signer = types.HomesteadSigner{}

diff --git official optimism/op-chain-ops/cmd/check-ecotone/main.go SWC optimism/op-chain-ops/cmd/check-ecotone/main.go index 10d5f72e7ad74e7fe4d0330d1b0f2e7b019fc587..5e52cc70f798b7a1eb1de91fa7003040b80473e8 100644 --- official optimism/op-chain-ops/cmd/check-ecotone/main.go +++ SWC optimism/op-chain-ops/cmd/check-ecotone/main.go @@ -786,7 +786,7 @@ Value: big.NewInt(3 * params.GWei), Data: []byte("hello"), AccessList: nil, } - tx, err := types.SignNewTx(env.key, types.NewIsthmusSigner(txData.ChainID), txData) + tx, err := types.SignNewTx(env.key, types.NewIsthmusSigner(txData.ChainID, false), txData) if err != nil { return fmt.Errorf("failed to sign test tx: %w", err) }

diff --git official optimism/op-chain-ops/cmd/check-fjord/checks/checks.go SWC optimism/op-chain-ops/cmd/check-fjord/checks/checks.go index a7063bbde9436164e6bf34267d48dd7d192c1f9e..6220067cf57225c89cf81381d1c6fab968f0309b 100644 --- official optimism/op-chain-ops/cmd/check-fjord/checks/checks.go +++ SWC optimism/op-chain-ops/cmd/check-fjord/checks/checks.go @@ -283,7 +283,8 @@ costFunc := types.NewL1CostFuncFjord( l1BaseFee, blobBaseFee, new(big.Int).SetUint64(uint64(baseFeeScalar)), - new(big.Int).SetUint64(uint64(blobBaseFeeScalar))) + new(big.Int).SetUint64(uint64(blobBaseFeeScalar)), + big.NewInt(1), big.NewInt(1))   fee, _ := costFunc(types.RollupCostData{FastLzSize: fastLzSize}) return fee, nil

diff --git official optimism/op-chain-ops/interopgen/deploy.go SWC optimism/op-chain-ops/interopgen/deploy.go index d18d78a29c23675237a894c89eee781adb129738..e681ce3438359be3cc43fb8b7a46fa7a8323aa43 100644 --- official optimism/op-chain-ops/interopgen/deploy.go +++ SWC optimism/op-chain-ops/interopgen/deploy.go @@ -334,6 +334,8 @@ Fork: big.NewInt(cfg.SolidityForkNumber(1)), DeployCrossL2Inbox: multichainDepSet, EnableGovernance: cfg.EnableGovernance, FundDevAccounts: cfg.FundDevAccounts, + DeploySoulGasToken: cfg.DeploySoulGasToken, + IsSoulBackedByNative: cfg.IsSoulBackedByNative, }); err != nil { return fmt.Errorf("failed L2 genesis: %w", err) }

diff --git official optimism/op-deployer/pkg/deployer/opcm/l2genesis.go SWC optimism/op-deployer/pkg/deployer/opcm/l2genesis.go index 3f91196cc85fca54a81f0c670b275255be5b33b2..1ea2e41cb0a6a63c3b6462b81cd135977ecf8f33 100644 --- official optimism/op-deployer/pkg/deployer/opcm/l2genesis.go +++ SWC optimism/op-deployer/pkg/deployer/opcm/l2genesis.go @@ -28,6 +28,8 @@ Fork *big.Int DeployCrossL2Inbox bool EnableGovernance bool FundDevAccounts bool + DeploySoulGasToken bool + IsSoulBackedByNative bool }   type L2GenesisScript script.DeployScriptWithoutOutput[L2GenesisInput]

diff --git official optimism/op-deployer/pkg/deployer/pipeline/l2genesis.go SWC optimism/op-deployer/pkg/deployer/pipeline/l2genesis.go index bb3f514358bcef96f3613a093120bc0936aa8a79..c977d0a903354654c90e3b68ff4088785e528cb0 100644 --- official optimism/op-deployer/pkg/deployer/pipeline/l2genesis.go +++ SWC optimism/op-deployer/pkg/deployer/pipeline/l2genesis.go @@ -31,6 +31,8 @@ L1FeeVaultWithdrawalNetwork genesis.WithdrawalNetwork `json:"l1FeeVaultWithdrawalNetwork"` SequencerFeeVaultWithdrawalNetwork genesis.WithdrawalNetwork `json:"sequencerFeeVaultWithdrawalNetwork"` EnableGovernance bool `json:"enableGovernance"` GovernanceTokenOwner common.Address `json:"governanceTokenOwner"` + DeploySoulGasToken bool `json:"deploySoulGasToken"` + IsSoulBackedByNative bool `json:"isSoulBackedByNative"` }   func GenerateL2Genesis(pEnv *Env, intent *state.Intent, bundle ArtifactsBundle, st *state.State, chainID common.Hash) error { @@ -94,6 +96,8 @@ Fork: big.NewInt(schedule.SolidityForkNumber(1)), DeployCrossL2Inbox: len(intent.Chains) > 1, EnableGovernance: overrides.EnableGovernance, FundDevAccounts: overrides.FundDevAccounts, + DeploySoulGasToken: overrides.DeploySoulGasToken, + IsSoulBackedByNative: overrides.IsSoulBackedByNative, }); err != nil { return fmt.Errorf("failed to call L2Genesis script: %w", err) }

diff --git official optimism/op-devstack/dsl/fjord_fees.go SWC optimism/op-devstack/dsl/fjord_fees.go index b27566634c71c1416ebd0137c6d7aba83b2be178..f72a33539911e0dea6c500baa43f42fa8782f9a7 100644 --- official optimism/op-devstack/dsl/fjord_fees.go +++ SWC optimism/op-devstack/dsl/fjord_fees.go @@ -196,7 +196,8 @@ ff.t.Logf("L1 fee is nil in receipt, skipping L1 fee validation") return fastLzSizeSigned, nil }   - expectedFee, err := CalculateFjordL1Cost(ff.ctx, client, signedTx.RollupCostData(), receipt.BlockHash) + scalar1, scalar2 := ff.l2Network.L1ScalarMultiplierConfig() + expectedFee, err := CalculateFjordL1Cost(ff.ctx, client, signedTx.RollupCostData(), receipt.BlockHash, scalar1, scalar2) ff.require.NoError(err, "should calculate L1 fee")   ff.require.Equalf(expectedFee, receiptL1Fee, "Calculated L1 fee should match receipt L1 fee (expected=%s actual=%s)", expectedFee.String(), receiptL1Fee.String()) @@ -329,7 +330,7 @@ require.Equalf(calculatedFee.Uint64(), receiptFee.Uint64(), "L1 fee mismatch (expected=%d actual=%d)", calculatedFee.Uint64(), receiptFee.Uint64()) }   // CalculateFjordL1Cost calculates L1 cost using Fjord formula with block-specific L1 state -func CalculateFjordL1Cost(ctx context.Context, client apis.EthClient, rollupCostData types.RollupCostData, blockHash common.Hash) (*big.Int, error) { +func CalculateFjordL1Cost(ctx context.Context, client apis.EthClient, rollupCostData types.RollupCostData, blockHash common.Hash, l1BaseFeeScalarMultiplier, l1BlobBaseFeeScalarMultiplier *big.Int) (*big.Int, error) { l1Block := bindings.NewL1Block( bindings.WithClient(client), bindings.WithTo(predeploys.L1BlockAddr), @@ -362,7 +363,9 @@ costFunc := types.NewL1CostFuncFjord( l1BaseFee, blobBaseFee, new(big.Int).SetUint64(uint64(baseFeeScalar)), - new(big.Int).SetUint64(uint64(blobBaseFeeScalar))) + new(big.Int).SetUint64(uint64(blobBaseFeeScalar)), + l1BaseFeeScalarMultiplier, + l1BlobBaseFeeScalarMultiplier)   fee, _ := costFunc(rollupCostData) return fee, nil

diff --git official optimism/op-devstack/dsl/l2_network.go SWC optimism/op-devstack/dsl/l2_network.go index adde64d626e1fca245cfdb1af73859021e17cb14..df348bbea8a0018e8305e858ccaf70bd0e1b7b38 100644 --- official optimism/op-devstack/dsl/l2_network.go +++ SWC optimism/op-devstack/dsl/l2_network.go @@ -3,6 +3,7 @@ import ( "fmt" "math" + "math/big" "time"   "github.com/davecgh/go-spew/spew" @@ -254,3 +255,7 @@ func (n *L2Network) DepositContractAddr() common.Address { return n.inner.RollupConfig().DepositContractAddress } + +func (n *L2Network) L1ScalarMultiplierConfig() (*big.Int, *big.Int) { + return n.inner.RollupConfig().ChainOpConfig.L1ScalarMultipliers(n.unsafeHeadRef().Time) +}

diff --git official optimism/op-e2e/actions/helpers/l2_sequencer.go SWC optimism/op-e2e/actions/helpers/l2_sequencer.go index 97d8100b1a5d694ad70fc048fe3070c7357ed7b8..b735ab85c13c2f4f54e5132538ab74caa9c3b722 100644 --- official optimism/op-e2e/actions/helpers/l2_sequencer.go +++ SWC optimism/op-e2e/actions/helpers/l2_sequencer.go @@ -73,7 +73,7 @@ seqStateListener := config.DisabledConfigPersistence{} conduc := &conductor.NoOpConductor{} asyncGossip := async.NoOpGossiper{} seq := sequencing.NewSequencer(t.Ctx(), log, cfg, attrBuilder, l1OriginSelector, - seqStateListener, conduc, asyncGossip, metr, ver.engine) + seqStateListener, conduc, asyncGossip, metr, ver.engine, nil) opts := event.WithEmitLimiter( // TestSyncBatchType/DerivationWithFlakyL1RPC does *a lot* of quick retries // TestL2BatcherBatchType/ExtendedTimeWithoutL1Batches as well.

diff --git official optimism/op-e2e/actions/proofs/isthmus_setcode_tx_test.go SWC optimism/op-e2e/actions/proofs/isthmus_setcode_tx_test.go index d05694ec8cd243ccb8791366086c6e9e2ae37ea6..9af8566aed5ebd90a2dbd5b7f30578a126670e36 100644 --- official optimism/op-e2e/actions/proofs/isthmus_setcode_tx_test.go +++ SWC optimism/op-e2e/actions/proofs/isthmus_setcode_tx_test.go @@ -98,7 +98,7 @@ GasFeeCap: uint256.NewInt(5000000000), GasTipCap: uint256.NewInt(2), AuthList: []types.SetCodeAuthorization{auth1, auth2}, } - signer := types.NewIsthmusSigner(chainID) + signer := types.NewIsthmusSigner(chainID, false) tx := types.MustSignNewTx(aliceSecret, signer, txdata)   err = cl.SendTransaction(t.Ctx(), tx) @@ -244,7 +244,7 @@ u1 := sequencer.L2Unsafe()   sequencer.ActL2EmptyBlock(t) // we'll inject the setcode tx in this block's batch   - signer := types.NewIsthmusSigner(chainID) + signer := types.NewIsthmusSigner(chainID, false)   rng := rand.New(rand.NewSource(0)) tx := testutils.RandomSetCodeTx(rng, signer)

diff --git official optimism/op-e2e/actions/proofs/operator_fee_test.go SWC optimism/op-e2e/actions/proofs/operator_fee_test.go index b024be821a9eb4ee2666fd8ff67813084dc1b21e..4f1f733afe77275c261f3f493d0461f452a2fc19 100644 --- official optimism/op-e2e/actions/proofs/operator_fee_test.go +++ SWC optimism/op-e2e/actions/proofs/operator_fee_test.go @@ -212,7 +212,7 @@ l1BlockInfo, err := derive.L1BlockInfoFromBytes(env.Sd.RollupCfg, unsafeHeader.Time, unsafeBlock.Transactions()[0].Data()) require.NoError(t, err)   - daCost := fjordL1Cost(l1BlockInfo, types.NewRollupCostData(rlp)) + daCost := fjordL1Cost(l1BlockInfo, types.NewRollupCostData(rlp, len(tx.BlobHashes()))) expectedFeePreIsthmus := nextBaseFee.Mul(nextBaseFee, big.NewInt(int64(params.TxGas))) expectedFeePreIsthmus.Add(expectedFeePreIsthmus, daCost)   @@ -380,7 +380,9 @@ // Ensure that the logs contain a mention of the block being replaced _due to the signer not having enough // balance_. require.NotNil(t, env.Logs.FindLog(testlog.NewAttributesContainsFilter("err", "insufficient funds for gas * price + value"))) - require.NotNil(t, env.Logs.FindLog(testlog.NewAttributesContainsFilter("err", "have 1400000021000 want 1400000086535"))) + // log diff is caused by sgt, which is enabled by default + require.NotNil(t, env.Logs.FindLog(testlog.NewAttributesContainsFilter("err", "have total balance 1400000021000 want 1400000086535"))) + // require.NotNil(t, env.Logs.FindLog(testlog.NewAttributesContainsFilter("err", "have 1400000021000 want 1400000086535"))) } else { require.Equal(t, len(safeHeadBlock.Transactions()), 2) } @@ -405,7 +407,10 @@ costFunc := types.NewL1CostFuncFjord( l1BlockInfo.BaseFee, l1BlockInfo.BlobBaseFee, new(big.Int).SetUint64(uint64(l1BlockInfo.BaseFeeScalar)), - new(big.Int).SetUint64(uint64(l1BlockInfo.BlobBaseFeeScalar))) + new(big.Int).SetUint64(uint64(l1BlockInfo.BlobBaseFeeScalar)), + new(big.Int).SetUint64(1), + new(big.Int).SetUint64(1), + )   fee, _ := costFunc(rollupCostData) return fee

diff --git official optimism/op-e2e/actions/upgrades/fjord_fork_test.go SWC optimism/op-e2e/actions/upgrades/fjord_fork_test.go index e7a4a8af8aab22d2df589f659bf6ac5e639f9315..813281be10da3ea9d6ef9d3437d67aca0de02721 100644 --- official optimism/op-e2e/actions/upgrades/fjord_fork_test.go +++ SWC optimism/op-e2e/actions/upgrades/fjord_fork_test.go @@ -134,7 +134,10 @@ costFunc := types.NewL1CostFuncFjord( l1BaseFee, blobBaseFee, new(big.Int).SetUint64(uint64(baseFeeScalar)), - new(big.Int).SetUint64(uint64(blobBaseFeeScalar))) + new(big.Int).SetUint64(uint64(blobBaseFeeScalar)), + new(big.Int).SetUint64(1), + new(big.Int).SetUint64(1), + )   fee, _ := costFunc(rollupCostData) return fee

diff --git official optimism/op-e2e/opgeth/fastlz_test.go SWC optimism/op-e2e/opgeth/fastlz_test.go index 5b03ca38eca3c1fa3356e12d5213ff5c185bcc82..3b910d41f816df5f3a223cfa4e03563b4636244c 100644 --- official optimism/op-e2e/opgeth/fastlz_test.go +++ SWC optimism/op-e2e/opgeth/fastlz_test.go @@ -173,7 +173,7 @@ l1FeeSolidity.Mul(l1FeeSolidity, feeScaled) l1FeeSolidity.Div(l1FeeSolidity, big.NewInt(1e12))   - costData := types.NewRollupCostData(fuzzedData) + costData := types.NewRollupCostData(fuzzedData, 0)   l1FeeGeth := costFunc(costData, zeroTime)

diff --git official optimism/op-e2e/system/bridge/deposit_test.go SWC optimism/op-e2e/system/bridge/deposit_test.go index 70d06c1c33b685f493af4aeee81a91467a146f36..4007e8766d1373e583c44f2f08d562e927ed836d 100644 --- official optimism/op-e2e/system/bridge/deposit_test.go +++ SWC optimism/op-e2e/system/bridge/deposit_test.go @@ -143,7 +143,7 @@ // Simple constructor that is prefixed to the actual contract code // Results in the contract code being returned as the code for the new contract deployData := append(deployPrefix, sstoreContract...) - signer := types.NewIsthmusSigner(cfg.L2ChainIDBig()) + signer := types.NewIsthmusSigner(cfg.L2ChainIDBig(), false)   tx := types.MustSignNewTx(cfg.Secrets.Alice, signer, &types.DynamicFeeTx{ ChainID: cfg.L2ChainIDBig(),

diff --git official optimism/op-e2e/system/runcfg/protocol_versions_test.go SWC optimism/op-e2e/system/runcfg/protocol_versions_test.go index 85daeff6c43657ae3a51ee500d1b638e92ecebdc..87a234711b7e01e3f30a0c94800e8bfc2354b221 100644 --- official optimism/op-e2e/system/runcfg/protocol_versions_test.go +++ SWC optimism/op-e2e/system/runcfg/protocol_versions_test.go @@ -128,6 +128,12 @@ t.Log("verified that op-node closed!") // Checking if the engine is down is not trivial in op-e2e. // In op-geth we have halting tests covering the Engine API, in op-e2e we instead check if the API stops. _, err = retry.Do(context.Background(), 10, retry.Fixed(time.Second*10), func() (struct{}, error) { + url := sys.NodeEndpoint("verifier").(endpoint.HttpRPC).HttpRPC() + // The URL of the verifier op-geth becomes empty after it is stopped. + // In this case, IsURLAvailable() returns an incorrect value when port 80 happens to be occupied by another process. + if url == "http://" { + return struct{}{}, nil + } available := client.IsURLAvailable(context.Background(), sys.NodeEndpoint("verifier").(endpoint.HttpRPC).HttpRPC(), 5*time.Second) if !available { // waiting for client to stop responding to RPC requests (slow dials with timeout don't count) return struct{}{}, nil

diff --git official optimism/op-node/config/config.go SWC optimism/op-node/config/config.go index 4aaa32ccf970aaea42693a6e4fac867de003802b..9de04fbe9390e05a06f80978357f5ce5e5a132f0 100644 --- official optimism/op-node/config/config.go +++ SWC optimism/op-node/config/config.go @@ -4,6 +4,9 @@ import ( "context" "errors" "fmt" + + "strings" + "time"   "github.com/ethereum/go-ethereum/log" @@ -14,13 +17,16 @@ "github.com/ethereum-optimism/optimism/op-node/node/tracer" "github.com/ethereum-optimism/optimism/op-node/p2p" "github.com/ethereum-optimism/optimism/op-node/rollup" "github.com/ethereum-optimism/optimism/op-node/rollup/driver" + "github.com/ethereum-optimism/optimism/op-node/rollup/engine" "github.com/ethereum-optimism/optimism/op-node/rollup/interop" "github.com/ethereum-optimism/optimism/op-node/rollup/sync" + "github.com/ethereum-optimism/optimism/op-service/cliiface" opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics" "github.com/ethereum-optimism/optimism/op-service/oppprof" oprpc "github.com/ethereum-optimism/optimism/op-service/rpc" "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/backend/depset" "github.com/ethereum/go-ethereum/params" + "github.com/ethstorage/da-server/pkg/da/client" )   type Config struct { @@ -84,6 +90,8 @@ ConductorRpcTimeout time.Duration   // AltDA config AltDA altda.CLIConfig + // DACConfig for sequencer when l2 blob is enabled + DACConfig *DACConfig   IgnoreMissingPectraBlobSchedule bool FetchWithdrawalRootFromState bool @@ -92,6 +100,27 @@ // Experimental. Enables new opstack RPC namespace. Used by op-test-sequencer. ExperimentalOPStackAPI bool }   +func ReadDACConfigFromCLI(c cliiface.Context) *DACConfig { + urls := c.String(flags.DACUrlsFlag.Name) + if urls == "" { + return nil + } + return &DACConfig{ + URLS: strings.Split(urls, ","), + } +} + +type DACConfig struct { + URLS []string +} + +func (dacConfig *DACConfig) Client() engine.DACClient { + if dacConfig == nil || len(dacConfig.URLS) == 0 { + return nil + } + return client.New(dacConfig.URLS) +} + // ConductorRPCFunc retrieves the endpoint. The RPC may not immediately be available. type ConductorRPCFunc func(ctx context.Context) (string, error)   @@ -180,6 +209,12 @@ return fmt.Errorf("altDA config error: %w", err) } if cfg.AltDA.Enabled { log.Warn("Alt-DA Mode is a Beta feature of the MIT licensed OP Stack. While it has received initial review from core contributors, it is still undergoing testing, and may have bugs or other issues.") + } + if cfg.Driver.SequencerEnabled && cfg.Rollup.IsL2BlobTimeSet() && cfg.DACConfig == nil { + return fmt.Errorf("dac.urls must be set for sequencer when l2 blob time is set") + } + if (!cfg.Driver.SequencerEnabled || !cfg.Rollup.IsL2BlobTimeSet()) && cfg.DACConfig != nil { + return fmt.Errorf("dac.urls can only be set for sequencer when l2 blob time is set") } return nil }

diff --git official optimism/op-node/rollup/derive/batch_test.go SWC optimism/op-node/rollup/derive/batch_test.go index c206739c979aeb9a9e92536d137266a7a0d7bf6f..4f67ef2e30e515554e720f29edaecf5adc213b7a 100644 --- official optimism/op-node/rollup/derive/batch_test.go +++ SWC optimism/op-node/rollup/derive/batch_test.go @@ -34,7 +34,7 @@ blockTxCount := 1 + uint64(rng.Intn(16)) blockTxCounts = append(blockTxCounts, blockTxCount) totalblockTxCounts += blockTxCount } - signer := types.NewIsthmusSigner(chainId) + signer := types.NewIsthmusSigner(chainId, false) var txs [][]byte for i := 0; i < int(totalblockTxCounts); i++ { var tx *types.Transaction

diff --git official optimism/op-node/rollup/derive/batch_test_utils.go SWC optimism/op-node/rollup/derive/batch_test_utils.go index bf28c1e00e656fb3afc5a2d2ad455bde71ce325b..a1007af5b62fc61edfb4e3b21d566bdc28f16545 100644 --- official optimism/op-node/rollup/derive/batch_test_utils.go +++ SWC optimism/op-node/rollup/derive/batch_test_utils.go @@ -11,7 +11,7 @@ "github.com/ethereum/go-ethereum/core/types" )   func RandomSingularBatch(rng *rand.Rand, txCount int, chainID *big.Int) *SingularBatch { - signer := types.NewIsthmusSigner(chainID) + signer := types.NewIsthmusSigner(chainID, false) baseFee := big.NewInt(rng.Int63n(300_000_000_000)) txsEncoded := make([]hexutil.Bytes, 0, txCount) // force each tx to have equal chainID

diff --git official optimism/op-node/rollup/derive/batches.go SWC optimism/op-node/rollup/derive/batches.go index 2e8c255d7fb2d421d3774a156d952f2579a74780..6974e807919015f3af09b630ab2b5f1608e8cef2 100644 --- official optimism/op-node/rollup/derive/batches.go +++ SWC optimism/op-node/rollup/derive/batches.go @@ -170,6 +170,7 @@ } }   isIsthmus := cfg.IsIsthmus(batch.Timestamp) + isL2Blob := cfg.IsL2Blob(batch.Timestamp)   // We can do this check earlier, but it's a more intensive one, so we do this last. for i, txBytes := range batch.Transactions { @@ -183,6 +184,10 @@ return BatchDrop } if !isIsthmus && txBytes[0] == types.SetCodeTxType { log.Warn("sequencers may not embed any SetCode transactions before Isthmus", "tx_index", i) + return BatchDrop + } + if !isL2Blob && txBytes[0] == types.BlobTxType { + log.Warn("sequencers may not embed any Blob transactions before L2Blob", "tx_index", i) return BatchDrop } }

diff --git official optimism/op-node/rollup/derive/batches_test.go SWC optimism/op-node/rollup/derive/batches_test.go index ade8d9df4c3cd255a1b9666f3aa15b9b9e0bf9eb..ae656c6368941dbc790cc7d0bf6c4cab0b7b518a 100644 --- official optimism/op-node/rollup/derive/batches_test.go +++ SWC optimism/op-node/rollup/derive/batches_test.go @@ -75,7 +75,7 @@ rng := rand.New(rand.NewSource(1234))   chainId := new(big.Int).SetUint64(rng.Uint64()) - signer := types.NewIsthmusSigner(chainId) + signer := types.NewIsthmusSigner(chainId, false) randTx := testutils.RandomTx(rng, new(big.Int).SetUint64(rng.Uint64()), signer) randTxData, _ := randTx.MarshalBinary()

diff --git official optimism/op-node/rollup/derive/span_batch_test.go SWC optimism/op-node/rollup/derive/span_batch_test.go index 96628c92c10ba213a1fe16524be4cf532ee94efc..e691fa58059966032a7f3cb3d300139fd38fb1be 100644 --- official optimism/op-node/rollup/derive/span_batch_test.go +++ SWC optimism/op-node/rollup/derive/span_batch_test.go @@ -485,7 +485,7 @@ for i, testCase := range cases { t.Run(testCase.name, func(t *testing.T) { rng := rand.New(rand.NewSource(int64(0x109550 + i))) chainID := new(big.Int).SetUint64(rng.Uint64()) - signer := types.NewIsthmusSigner(chainID) + signer := types.NewIsthmusSigner(chainID, false) if !testCase.protected { signer = types.HomesteadSigner{} }

diff --git official optimism/op-node/rollup/derive/span_batch_tx_test.go SWC optimism/op-node/rollup/derive/span_batch_tx_test.go index d215a0f2c6be01a30b3421e44c3d34b768941687..d39278856869f6385426f4c5fc99dbffe6642798 100644 --- official optimism/op-node/rollup/derive/span_batch_tx_test.go +++ SWC optimism/op-node/rollup/derive/span_batch_tx_test.go @@ -31,7 +31,7 @@ for i, testCase := range cases { t.Run(testCase.name, func(t *testing.T) { rng := rand.New(rand.NewSource(int64(0x1331 + i))) chainID := big.NewInt(rng.Int63n(1000)) - signer := types.NewIsthmusSigner(chainID) + signer := types.NewIsthmusSigner(chainID, false) if !testCase.protected { signer = types.HomesteadSigner{} } @@ -71,7 +71,7 @@ for i, testCase := range cases { t.Run(testCase.name, func(t *testing.T) { rng := rand.New(rand.NewSource(int64(0x1332 + i))) chainID := big.NewInt(rng.Int63n(1000)) - signer := types.NewIsthmusSigner(chainID) + signer := types.NewIsthmusSigner(chainID, false) if !testCase.protected { signer = types.HomesteadSigner{} }

diff --git official optimism/op-node/rollup/derive/test/random.go SWC optimism/op-node/rollup/derive/test/random.go index 24f28bb174a37ee9cb5a10c6e730b87b89400a9b..1ccece081f1fa501bbda19fc16edc7fa9b0cffcd 100644 --- official optimism/op-node/rollup/derive/test/random.go +++ SWC optimism/op-node/rollup/derive/test/random.go @@ -41,7 +41,7 @@ return RandomL2BlockWithChainIdAndTime(rng, txCount, chainId, time.Time{}) }   func RandomL2BlockWithChainIdAndTime(rng *rand.Rand, txCount int, chainId *big.Int, t time.Time) *types.Block { - signer := types.NewIsthmusSigner(chainId) + signer := types.NewIsthmusSigner(chainId, false) block, _ := RandomL2Block(rng, 0, t) txs := []*types.Transaction{block.Transactions()[0]} // L1 info deposit TX for i := 0; i < txCount; i++ {