feat: adds a revert check in tests

Author: ckartik

oracle/pkg/updater/updater_test.go

@@ -318,6 +318,266 @@ func TestUpdater(t *testing.T) {
 	}
 }
 
+func TestUpdaterRevertedTxns(t *testing.T) {
+	t.Parallel()
+
+	// timestamp of the First block commitment is X
+	startTimestamp := time.UnixMilli(1615195200000)
+	midTimestamp := startTimestamp.Add(time.Duration(2.5 * float64(time.Second)))
+	endTimestamp := startTimestamp.Add(5 * time.Second)
+
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	builderAddr := common.HexToAddress("0xabcd")
+	otherBuilderAddr := common.HexToAddress("0xabdc")
+
+	signer := types.NewLondonSigner(big.NewInt(5))
+	var txns []*types.Transaction
+	for i := 0; i < 10; i++ {
+		txns = append(txns, types.MustSignNewTx(key, signer, &types.DynamicFeeTx{
+			Nonce:     uint64(i + 1),
+			Gas:       1000000,
+			Value:     big.NewInt(1),
+			GasTipCap: big.NewInt(500),
+			GasFeeCap: big.NewInt(500),
+		}))
+	}
+
+	encCommitments := make([]preconf.PreconfcommitmentstoreEncryptedCommitmentStored, 0)
+	commitments := make([]preconf.PreconfcommitmentstoreCommitmentStored, 0)
+
+	for i, txn := range txns {
+		idxBytes := getIdxBytes(int64(i))
+
+		encCommitment := preconf.PreconfcommitmentstoreEncryptedCommitmentStored{
+			CommitmentIndex:     idxBytes,
+			CommitmentDigest:    common.HexToHash(fmt.Sprintf("0x%02d", i)),
+			CommitmentSignature: []byte("signature"),
+			DispatchTimestamp:   uint64(midTimestamp.UnixMilli()),
+		}
+		commitment := preconf.PreconfcommitmentstoreCommitmentStored{
+			CommitmentIndex:     idxBytes,
+			TxnHash:             strings.TrimPrefix(txn.Hash().Hex(), "0x"),
+			Bid:                 big.NewInt(10),
+			BlockNumber:         5,
+			CommitmentHash:      common.HexToHash(fmt.Sprintf("0x%02d", i)),
+			CommitmentSignature: []byte("signature"),
+			DecayStartTimeStamp: uint64(startTimestamp.UnixMilli()),
+			DecayEndTimeStamp:   uint64(endTimestamp.UnixMilli()),
+			DispatchTimestamp:   uint64(midTimestamp.UnixMilli()),
+		}
+
+		if i%2 == 0 {
+			encCommitment.Commiter = builderAddr
+			commitment.Commiter = builderAddr
+			encCommitments = append(encCommitments, encCommitment)
+			commitments = append(commitments, commitment)
+		} else {
+			encCommitment.Commiter = otherBuilderAddr
+			commitment.Commiter = otherBuilderAddr
+			encCommitments = append(encCommitments, encCommitment)
+			commitments = append(commitments, commitment)
+		}
+	}
+
+	// constructing bundles
+	for i := 0; i < 10; i++ {
+		idxBytes := getIdxBytes(int64(i + 10))
+
+		bundle := strings.TrimPrefix(txns[i].Hash().Hex(), "0x")
+		for j := i + 1; j < 10; j++ {
+			bundle += "," + strings.TrimPrefix(txns[j].Hash().Hex(), "0x")
+		}
+
+		encCommitment := preconf.PreconfcommitmentstoreEncryptedCommitmentStored{
+			CommitmentIndex:     idxBytes,
+			Commiter:            builderAddr,
+			CommitmentDigest:    common.HexToHash(fmt.Sprintf("0x%02d", i)),
+			CommitmentSignature: []byte("signature"),
+			DispatchTimestamp:   uint64(midTimestamp.UnixMilli()),
+		}
+		commitment := preconf.PreconfcommitmentstoreCommitmentStored{
+			CommitmentIndex:     idxBytes,
+			Commiter:            builderAddr,
+			Bid:                 big.NewInt(10),
+			TxnHash:             bundle,
+			BlockNumber:         5,
+			CommitmentHash:      common.HexToHash(fmt.Sprintf("0x%02d", i)),
+			CommitmentSignature: []byte("signature"),
+			DecayStartTimeStamp: uint64(startTimestamp.UnixMilli()),
+			DecayEndTimeStamp:   uint64(endTimestamp.UnixMilli()),
+			DispatchTimestamp:   uint64(midTimestamp.UnixMilli()),
+		}
+		encCommitments = append(encCommitments, encCommitment)
+		commitments = append(commitments, commitment)
+	}
+
+	register := &testWinnerRegister{
+		winners: []testWinner{
+			{
+				blockNum: 5,
+				winner: updater.Winner{
+					Winner: builderAddr.Bytes(),
+					Window: 1,
+				},
+			},
+		},
+		settlements: make(chan testSettlement, 1),
+		encCommit:   make(chan testEncryptedCommitment, 1),
+	}
+
+	l1Client := &testEVMClient{
+		blocks: map[int64]*types.Block{
+			5: types.NewBlock(&types.Header{}, txns, nil, nil, NewHasher()),
+		},
+		receipts: make(map[string]*types.Receipt),
+	}
+	for _, txn := range txns {
+		receipt := &types.Receipt{
+			Status: types.ReceiptStatusFailed,
+			TxHash: txn.Hash(),
+		}
+		l1Client.receipts[txn.Hash().Hex()] = receipt
+	}
+
+	pcABI, err := abi.JSON(strings.NewReader(preconf.PreconfcommitmentstoreABI))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	btABI, err := abi.JSON(strings.NewReader(blocktracker.BlocktrackerABI))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	evtMgr := events.NewListener(
+		util.NewTestLogger(io.Discard),
+		&btABI,
+		&pcABI,
+	)
+
+	oracle := &testOracle{
+		commitments: make(chan processedCommitment, 1),
+	}
+
+	updtr, err := updater.NewUpdater(
+		slog.New(slog.NewTextHandler(io.Discard, nil)),
+		l1Client,
+		register,
+		evtMgr,
+		oracle,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	done := updtr.Start(ctx)
+
+	w := blocktracker.BlocktrackerNewWindow{
+		Window: big.NewInt(1),
+	}
+	publishNewWindow(evtMgr, &btABI, w)
+
+	for _, ec := range encCommitments {
+		if err := publishEncCommitment(evtMgr, &pcABI, ec); err != nil {
+			t.Fatal(err)
+		}
+
+		select {
+		case <-time.After(5 * time.Second):
+			t.Fatal("timeout")
+		case enc := <-register.encCommit:
+			if !bytes.Equal(enc.commitmentIdx, ec.CommitmentIndex[:]) {
+				t.Fatal("wrong commitment index")
+			}
+			if !bytes.Equal(enc.committer, ec.Commiter.Bytes()) {
+				t.Fatal("wrong committer")
+			}
+			if !bytes.Equal(enc.commitmentHash, ec.CommitmentDigest[:]) {
+				t.Fatal("wrong commitment hash")
+			}
+			if !bytes.Equal(enc.commitmentSignature, ec.CommitmentSignature) {
+				t.Fatal("wrong commitment signature")
+			}
+			if enc.dispatchTimestamp != ec.DispatchTimestamp {
+				t.Fatal("wrong dispatch timestamp")
+			}
+		}
+	}
+
+	for _, c := range commitments {
+		if err := publishCommitment(evtMgr, &pcABI, c); err != nil {
+			t.Fatal(err)
+		}
+
+		if c.Commiter.Cmp(otherBuilderAddr) == 0 {
+			continue
+		}
+
+		select {
+		case <-time.After(5 * time.Second):
+			t.Fatal("timeout")
+		case commitment := <-oracle.commitments:
+			if !bytes.Equal(commitment.commitmentIdx[:], c.CommitmentIndex[:]) {
+				t.Fatal("wrong commitment index")
+			}
+			if commitment.blockNum.Cmp(big.NewInt(5)) != 0 {
+				t.Fatal("wrong block number")
+			}
+			if commitment.builder != c.Commiter {
+				t.Fatal("wrong builder")
+			}
+			if !commitment.isSlash {
+				t.Fatal("wrong isSlash")
+			}
+			if commitment.residualDecay.Cmp(big.NewInt(50)) != 0 {
+				t.Fatal("wrong residual decay")
+			}
+		}
+
+		select {
+		case <-time.After(5 * time.Second):
+			t.Fatal("timeout")
+		case settlement := <-register.settlements:
+			if !bytes.Equal(settlement.commitmentIdx, c.CommitmentIndex[:]) {
+				t.Fatal("wrong commitment index")
+			}
+			if settlement.txHash != c.TxnHash {
+				t.Fatal("wrong txn hash")
+			}
+			if settlement.blockNum != 5 {
+				t.Fatal("wrong block number")
+			}
+			if !bytes.Equal(settlement.builder, c.Commiter.Bytes()) {
+				t.Fatal("wrong builder")
+			}
+			if settlement.amount.Uint64() != 10 {
+				t.Fatal("wrong amount")
+			}
+			if settlement.settlementType != updater.SettlementTypeSlash {
+				t.Fatal("wrong settlement type")
+			}
+			if settlement.decayPercentage != 50 {
+				t.Fatal("wrong decay percentage")
+			}
+			if settlement.window != 1 {
+				t.Fatal("wrong window")
+			}
+		}
+	}
+
+	cancel()
+	select {
+	case <-done:
+	case <-time.After(5 * time.Second):
+		t.Fatal("timeout")
+	}
+}
+
 func TestUpdaterBundlesFailure(t *testing.T) {
 	t.Parallel()