898 oldaccinputhash for lower forkids

cmd/rpcdaemon/commands/zkevm_api.go

@@ -13,6 +13,7 @@ import (
 	"github.com/gateway-fm/cdk-erigon-lib/kv"
 	"github.com/gateway-fm/cdk-erigon-lib/kv/memdb"
 	jsoniter "github.com/json-iterator/go"
+	zktypes "github.com/ledgerwatch/erigon/zk/types"
 
 	"github.com/holiman/uint256"
 	"github.com/ledgerwatch/erigon/common/hexutil"
@@ -43,7 +44,6 @@ import (
 	"github.com/ledgerwatch/erigon/zk/witness"
 	"github.com/ledgerwatch/erigon/zkevm/hex"
 	"github.com/ledgerwatch/erigon/zkevm/jsonrpc/client"
-	"github.com/ledgerwatch/log/v3"
 )
 
 var sha3UncleHash = common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347")
@@ -459,7 +459,6 @@ func (api *ZkEvmAPIImpl) GetBatchByNumber(ctx context.Context, batchNumber rpc.B
 	}
 	defer tx.Rollback()
 	hermezDb := hermez_db.NewHermezDbReader(tx)
-
 	// use inbuilt rpc.BlockNumber type to implement the 'latest' behaviour
 	// the highest block/batch is tied to last block synced
 	// unless the node is still syncing - in which case 'current block' is used
@@ -699,12 +698,14 @@ func (api *ZkEvmAPIImpl) GetBatchByNumber(ctx context.Context, batchNumber rpc.B
 	}
 	batch.BatchL2Data = batchL2Data
 
-	oldAccInputHash, err := api.l1Syncer.GetOldAccInputHash(ctx, &api.config.AddressRollup, api.config.L1RollupId, batchNo)
+	accInputHash, err := api.getAccInputHash(ctx, hermezDb, batchNo)
 	if err != nil {
-		log.Warn("Failed to get old acc input hash", "err", err)
-		batch.AccInputHash = common.Hash{}
+		return nil, fmt.Errorf("failed to get acc input hash for batch %d: %w", batchNo, err)
+	}
+	if accInputHash == nil {
+		return nil, fmt.Errorf("acc input hash not found for batch %d", batchNo)
 	}
-	batch.AccInputHash = oldAccInputHash
+	batch.AccInputHash = *accInputHash
 
 	// forkid exit roots logic
 	// if forkid < 12 then we should only set the exit roots if they have changed, otherwise 0x00..00
@@ -731,6 +732,90 @@ func (api *ZkEvmAPIImpl) GetBatchByNumber(ctx context.Context, batchNumber rpc.B
 	return populateBatchDetails(batch)
 }
 
+type SequenceReader interface {
+	GetRangeSequencesByBatch(batchNo uint64) (*zktypes.L1BatchInfo, *zktypes.L1BatchInfo, error)
+	GetForkId(batchNo uint64) (uint64, error)
+}
+
+func (api *ZkEvmAPIImpl) getAccInputHash(ctx context.Context, db SequenceReader, batchNum uint64) (accInputHash *common.Hash, err error) {
+	// get batch sequence
+	prevSequence, batchSequence, err := db.GetRangeSequencesByBatch(batchNum)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get sequence range data for batch %d: %w", batchNum, err)
+	}
+
+	// get batch range for sequence
+	prevSequenceBatch, currentSequenceBatch := prevSequence.BatchNo, batchSequence.BatchNo
+	// get call data for tx
+	l1Transaction, _, err := api.l1Syncer.GetTransaction(batchSequence.L1TxHash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get transaction data for tx %s: %w", batchSequence.L1TxHash, err)
+	}
+	sequenceBatchesCalldata := l1Transaction.GetData()
+	if len(sequenceBatchesCalldata) < 10 {
+		return nil, fmt.Errorf("calldata for tx %s is too short", batchSequence.L1TxHash)
+	}
+
+	//TODO: get forkid for both batches
+	currentBatchForkId, err := db.GetForkId(currentSequenceBatch)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get fork id for batch %d: %w", currentSequenceBatch, err)
+	}
+
+	// get old and new acc input hashes
+	if currentBatchForkId < uint64(constants.ForkID7Etrog) {
+		prevAccInputHash, err := api.l1Syncer.GetPreEtrogAccInputHash(ctx, &api.config.AddressRollup, prevSequenceBatch)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get old acc input hash for batch %d: %w", prevSequenceBatch, err)
+		}
+
+		// from calldata get batchTransactions, GER, timestamp, l2Coinbase
+		decodedCalldata, err := syncer.DecodePreEtrogSequenceBatchesCallData(sequenceBatchesCalldata)
+		if err != nil {
+			return nil, fmt.Errorf("failed to decode calldata for tx %s: %w", batchSequence.L1TxHash, err)
+		}
+
+		// calculate acc input hash
+		for i, dec := range decodedCalldata.Batches {
+			currentAccInputHash, err := utils.CalculatePreEtrogAccInputHash(prevAccInputHash, dec.Transactions, dec.GlobalExitRoot, dec.Timestamp, decodedCalldata.L2Coinbase)
+			if err != nil {
+				return nil, fmt.Errorf("failed to calculate acc input hash for batch %d: %w", currentSequenceBatch, err)
+			}
+			if prevSequenceBatch+uint64(i)+uint64(1) == batchNum {
+				accInputHash = &currentAccInputHash
+				break
+			}
+			prevAccInputHash = currentAccInputHash
+		}
+	} else {
+		prevAccInputHash, err := api.l1Syncer.GetEtrogAccInputHash(ctx, &api.config.AddressRollup, api.config.L1RollupId, prevSequenceBatch)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get old acc input hash for batch %d: %w", prevSequenceBatch, err)
+		}
+
+		// from calldata get batchTransactions, GER, timestamp, l2Coinbase
+		decodedCalldata, err := syncer.DecodeEtrogSequenceBatchesCallData(sequenceBatchesCalldata)
+		if err != nil {
+			return nil, fmt.Errorf("failed to decode calldata for tx %s: %w", batchSequence.L1TxHash, err)
+		}
+
+		// calculate acc input hash
+		for i, dec := range decodedCalldata.Batches {
+			currentAccInputHash, err := utils.CalculateEtrogAccInputHash(prevAccInputHash, dec.Transactions, batchSequence.L1InfoRoot, decodedCalldata.MaxSequenceTimestamp, decodedCalldata.L2Coinbase, dec.ForcedBlockHashL1)
+			if err != nil {
+				return nil, fmt.Errorf("failed to calculate acc input hash for batch %d: %w", currentSequenceBatch, err)
+			}
+			if prevSequenceBatch+uint64(i)+uint64(1) == batchNum {
+				accInputHash = &currentAccInputHash
+				break
+			}
+			prevAccInputHash = currentAccInputHash
+		}
+	}
+
+	return
+}
+
 // GetFullBlockByNumber returns a full block from the current canonical chain. If number is nil, the
 // latest known block is returned.
 func (api *ZkEvmAPIImpl) GetFullBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (types.Block, error) {
@@ -1071,9 +1156,15 @@ func (api *ZkEvmAPIImpl) GetProverInput(ctx context.Context, batchNumber uint64,
 		return nil, err
 	}
 
-	oldAccInputHash, err := api.l1Syncer.GetOldAccInputHash(ctx, &api.config.AddressRollup, api.config.L1RollupId, batchNumber)
-	if err != nil {
-		return nil, err
+	var oldAccInputHash common.Hash
+	if batchNumber > 0 {
+		oaih, err := api.getAccInputHash(ctx, hDb, batchNumber-1)
+		if err != nil {
+			return nil, err
+		}
+		oldAccInputHash = *oaih
+	} else {
+		oldAccInputHash = common.Hash{}
 	}
 
 	timestampLimit := lastBlock.Time()

migrations/migrations.go

@@ -37,6 +37,7 @@ var migrations = map[kv.Label][]Migration{
 		resetBlocks4,
 		refactorTableLastRoot,
 		countersToArray,
+		resetL1Sequences,
 	},
 	kv.TxPoolDB: {},
 	kv.SentryDB: {},

migrations/reset_l1sequences.go

@@ -0,0 +1,33 @@
+package migrations
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gateway-fm/cdk-erigon-lib/common/datadir"
+	"github.com/gateway-fm/cdk-erigon-lib/kv"
+	"github.com/ledgerwatch/erigon/eth/stagedsync/stages"
+)
+
+var resetL1Sequences = Migration{
+	Name: "remove l1 sequences and stage_l1sync progress to download all l1 sequences anew",
+	Up: func(db kv.RwDB, dirs datadir.Dirs, progress []byte, BeforeCommit Callback) (err error) {
+		tx, err := db.BeginRw(context.Background())
+		if err != nil {
+			return err
+		}
+		defer tx.Rollback()
+		tx.ClearBucket(kv.L1SEQUENCES)
+
+		// already checked
+		if err := stages.SaveStageProgress(tx, stages.L1Syncer, 0); err != nil {
+			return fmt.Errorf("failed to get highest checked block, %w", err)
+		}
+
+		// This migration is no-op, but it forces the migration mechanism to apply it and thus write the DB schema version info
+		if err := BeforeCommit(tx, nil, true); err != nil {
+			return err
+		}
+		return tx.Commit()
+	},
+}