feat(driver): improve ResetL1Current method based on the latest pro…

…tocol changes (#445)

bindings/.githead

@@ -1 +1 @@
-b6abb0d5e06860fb731b4de0d812c82c6985f1f7
+7090d5f5c7e4f290a87b42e83d73accdbfe176c7

bindings/encoding/input.go

@@ -53,6 +53,14 @@ var (
 			Name: "l1Height",
 			Type: "uint64",
 		},
+		{
+			Name: "txListByteOffset",
+			Type: "uint24",
+		},
+		{
+			Name: "txListByteSize",
+			Type: "uint24",
+		},
 		{
 			Name: "minTier",
 			Type: "uint16",
@@ -100,6 +108,22 @@ var (
 			Name: "extraData",
 			Type: "bytes32",
 		},
+		{
+			Name: "blobHash",
+			Type: "bytes32",
+		},
+		{
+			Name: "txListByteOffset",
+			Type: "uint24",
+		},
+		{
+			Name: "txListByteSize",
+			Type: "uint24",
+		},
+		{
+			Name: "cacheBlobForReuse",
+			Type: "bool",
+		},
 	}
 	proverAssignmentComponents = []abi.ArgumentMarshaling{
 		{
@@ -160,6 +184,7 @@ var (
 	)
 	proverAssignmentPayloadArgs = abi.Arguments{
 		{Name: "PROVER_ASSIGNMENT", Type: stringType},
+		{Name: "taikoAddress", Type: addressType},
 		{Name: "blobHash", Type: bytes32Type},
 		{Name: "assignment.feeToken", Type: addressType},
 		{Name: "assignment.expiry", Type: uint64Type},
@@ -204,12 +229,13 @@ func EncodeBlockParams(params *BlockParams) ([]byte, error) {
 
 // EncodeProverAssignmentPayload performs the solidity `abi.encode` for the given proverAssignment payload.
 func EncodeProverAssignmentPayload(
+	taikoAddress common.Address,
 	txListHash common.Hash,
 	feeToken common.Address,
 	expiry uint64,
 	tierFees []TierFee,
 ) ([]byte, error) {
-	b, err := proverAssignmentPayloadArgs.Pack("PROVER_ASSIGNMENT", txListHash, feeToken, expiry, tierFees)
+	b, err := proverAssignmentPayloadArgs.Pack("PROVER_ASSIGNMENT", taikoAddress, txListHash, feeToken, expiry, tierFees)
 	if err != nil {
 		return nil, fmt.Errorf("failed to abi.encode prover assignment hash payload, %w", err)
 	}

bindings/encoding/input_test.go

@@ -17,6 +17,7 @@ import (
 
 func TestEncodeProverAssignmentPayload(t *testing.T) {
 	encoded, err := EncodeProverAssignmentPayload(
+		common.BytesToAddress(randomBytes(20)),
 		common.BytesToHash(randomBytes(32)),
 		common.BytesToAddress(randomBytes(20)),
 		120,

bindings/encoding/struct.go

@@ -40,8 +40,12 @@ type BlockHeader struct {
 
 // BlockParams should be same with TaikoData.BlockParams.
 type BlockParams struct {
-	Assignment *ProverAssignment
-	ExtraData  [32]byte
+	Assignment        *ProverAssignment
+	ExtraData         [32]byte
+	BlobHash          [32]byte
+	TxListByteOffset  *big.Int
+	TxListByteSize    *big.Int
+	CacheBlobForReuse bool
 }
 
 // TierFee should be same with TaikoData.TierFee.

driver/chain_syncer/chain_syncer.go

@@ -99,7 +99,7 @@ func (s *L2ChainSyncer) Sync(l1End *types.Header) error {
 		)
 
 		// Reset the L1Current cursor.
-		if _, err := s.state.ResetL1Current(s.ctx, l2Head.Number); err != nil {
+		if err := s.state.ResetL1Current(s.ctx, l2Head.Number); err != nil {
 			return err
 		}
 

driver/driver_test.go

@@ -307,8 +307,7 @@ func (s *DriverTestSuite) TestL1Current() {
 	// propose and insert a block
 	testutils.ProposeAndInsertEmptyBlocks(&s.ClientTestSuite, s.p, s.d.ChainSyncer().CalldataSyncer())
 	// reset L1 current with increased height
-	_, err := s.d.state.ResetL1Current(s.d.ctx, common.Big1)
-	s.Nil(err)
+	s.Nil(s.d.state.ResetL1Current(s.d.ctx, common.Big1))
 }
 
 func TestDriverTestSuite(t *testing.T) {

driver/state/l1_current.go

@@ -5,11 +5,10 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/taikoxyz/taiko-client/bindings"
-	eventIterator "github.com/taikoxyz/taiko-client/pkg/chain_iterator/event_iterator"
 )
 
 // GetL1Current reads the L1 current cursor concurrent safely.
@@ -32,62 +31,34 @@ func (s *State) SetL1Current(h *types.Header) {
 func (s *State) ResetL1Current(
 	ctx context.Context,
 	blockID *big.Int,
-) (*bindings.TaikoL1ClientBlockProposed, error) {
+) error {
 	if blockID == nil {
-		return nil, fmt.Errorf("empty block ID")
+		return fmt.Errorf("empty block ID")
 	}
 
 	log.Info("Reset L1 current cursor", "blockID", blockID)
 
 	if blockID.Cmp(common.Big0) == 0 {
 		l1Current, err := s.rpc.L1.HeaderByNumber(ctx, s.GenesisL1Height)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		s.SetL1Current(l1Current)
-		return nil, nil
+		return nil
 	}
 
-	var event *bindings.TaikoL1ClientBlockProposed
-	iter, err := eventIterator.NewBlockProposedIterator(
-		ctx,
-		&eventIterator.BlockProposedIteratorConfig{
-			Client:      s.rpc.L1,
-			TaikoL1:     s.rpc.TaikoL1,
-			StartHeight: s.GenesisL1Height,
-			EndHeight:   s.GetL1Head().Number,
-			FilterQuery: []*big.Int{blockID},
-			Reverse:     true,
-			OnBlockProposedEvent: func(
-				ctx context.Context,
-				e *bindings.TaikoL1ClientBlockProposed,
-				end eventIterator.EndBlockProposedEventIterFunc,
-			) error {
-				event = e
-				end()
-				return nil
-			},
-		},
-	)
+	blockInfo, err := s.rpc.TaikoL1.GetBlock(&bind.CallOpts{Context: ctx}, blockID.Uint64())
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	if err := iter.Iter(); err != nil {
-		return nil, err
-	}
-
-	if event == nil {
-		return nil, fmt.Errorf("BlockProposed event not found, blockID: %s", blockID)
-	}
-
-	l1Current, err := s.rpc.L1.HeaderByNumber(ctx, new(big.Int).SetUint64(event.Raw.BlockNumber))
+	l1Current, err := s.rpc.L1.HeaderByNumber(ctx, new(big.Int).SetUint64(blockInfo.ProposedIn))
 	if err != nil {
-		return nil, err
+		return err
 	}
 	s.SetL1Current(l1Current)
 
-	log.Info("Reset L1 current cursor", "height", s.GetL1Current().Number)
+	log.Info("Reset L1 current cursor", "height", s.GetL1Current().Number, "hash", s.GetL1Current().Hash())
 
-	return event, nil
+	return nil
 }

driver/state/l1_current_test.go

@@ -18,27 +18,19 @@ func (s *DriverStateTestSuite) TestSetL1Current() {
 	s.Equal(h.Hash(), s.s.GetL1Current().Hash())
 
 	// should warn, but not panic
-	s.NotPanics(func() {
-		s.s.SetL1Current(nil)
-	})
+	s.NotPanics(func() { s.s.SetL1Current(nil) })
 }
 
 func (s *DriverStateTestSuite) TestResetL1CurrentEmptyHeight() {
-	_, err := s.s.ResetL1Current(context.Background(), common.Big0)
-	s.Nil(err)
-
-	_, err = s.s.ResetL1Current(context.Background(), common.Big0)
-	s.Nil(err)
+	s.Nil(s.s.ResetL1Current(context.Background(), common.Big0))
 }
 
 func (s *DriverStateTestSuite) TestResetL1CurrentEmptyID() {
-	_, err := s.s.ResetL1Current(context.Background(), common.Big1)
-	s.ErrorContains(err, "not found")
+	s.ErrorContains(s.s.ResetL1Current(context.Background(), common.Big1), "execution reverted")
 }
 
 func (s *DriverStateTestSuite) TestResetL1CurrentCtxErr() {
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
-	_, err := s.s.ResetL1Current(ctx, common.Big0)
-	s.ErrorContains(err, "context canceled")
+	s.ErrorContains(s.s.ResetL1Current(ctx, common.Big0), "context canceled")
 }

proposer/proposer.go

@@ -369,8 +369,12 @@ func (p *Proposer) sendProposeBlockTx(
 	}
 
 	encodedParams, err := encoding.EncodeBlockParams(&encoding.BlockParams{
-		Assignment: assignment,
-		ExtraData:  rpc.StringToBytes32(p.cfg.ExtraData),
+		Assignment:        assignment,
+		ExtraData:         rpc.StringToBytes32(p.cfg.ExtraData),
+		TxListByteOffset:  common.Big0,
+		TxListByteSize:    common.Big0,
+		BlobHash:          [32]byte{},
+		CacheBlobForReuse: false,
 	})
 	if err != nil {
 		return nil, err

proposer/prover_selector/eth_fee_eoa_selector.go

@@ -124,6 +124,7 @@ func (s *ETHFeeEOASelector) AssignProver(
 				endpoint,
 				expiry,
 				tierFees,
+				s.taikoL1Address,
 				txListHash,
 				s.requestTimeout,
 				guardianProverAddress,
@@ -169,6 +170,7 @@ func assignProver(
 	endpoint *url.URL,
 	expiry uint64,
 	tierFees []encoding.TierFee,
+	taikoL1Address common.Address,
 	txListHash common.Hash,
 	timeout time.Duration,
 	guardianProverAddress common.Address,
@@ -215,7 +217,7 @@ func assignProver(
 
 	// Ensure prover in response is the same as the one recovered
 	// from the signature
-	payload, err := encoding.EncodeProverAssignmentPayload(txListHash, common.Address{}, expiry, tierFees)
+	payload, err := encoding.EncodeProverAssignmentPayload(taikoL1Address, txListHash, common.Address{}, expiry, tierFees)
 	if err != nil {
 		return nil, common.Address{}, err
 	}

prover/prover.go

@@ -685,12 +685,12 @@ func (p *Prover) onTransitionContested(ctx context.Context, e *bindings.TaikoL1C
 		return nil
 	}
 
-	l1Height, err := p.rpc.TaikoL2.LatestSyncedL1Height(&bind.CallOpts{Context: ctx, BlockNumber: e.BlockId})
+	blockInfo, err := p.rpc.TaikoL1.GetBlock(&bind.CallOpts{Context: ctx}, e.BlockId.Uint64())
 	if err != nil {
 		return err
 	}
 
-	return p.requestProofByBlockID(e.BlockId, new(big.Int).SetUint64(l1Height+1), e.Tier+1, nil)
+	return p.requestProofByBlockID(e.BlockId, new(big.Int).SetUint64(blockInfo.ProposedIn), e.Tier+1, nil)
 }
 
 // onBlockVerified update the latestVerified block in current state, and cancels
@@ -747,22 +747,22 @@ func (p *Prover) onTransitionProved(ctx context.Context, event *bindings.TaikoL1
 		return nil
 	}
 
-	l1Height, err := p.rpc.TaikoL2.LatestSyncedL1Height(&bind.CallOpts{Context: ctx, BlockNumber: event.BlockId})
+	blockInfo, err := p.rpc.TaikoL1.GetBlock(&bind.CallOpts{Context: ctx}, event.BlockId.Uint64())
 	if err != nil {
 		return err
 	}
 
 	log.Info(
 		"Contest a proven transition",
 		"blockID", event.BlockId,
-		"l1Height", l1Height,
+		"l1Height", blockInfo.ProposedIn,
 		"tier", event.Tier,
 		"parentHash", common.Bytes2Hex(event.Tran.ParentHash[:]),
 		"blockHash", common.Bytes2Hex(event.Tran.BlockHash[:]),
 		"signalRoot", common.Bytes2Hex(event.Tran.SignalRoot[:]),
 	)
 
-	return p.requestProofByBlockID(event.BlockId, new(big.Int).SetUint64(l1Height+1), event.Tier, event)
+	return p.requestProofByBlockID(event.BlockId, new(big.Int).SetUint64(blockInfo.ProposedIn), event.Tier, event)
 }
 
 // Name returns the application name.

prover/prover_test.go

@@ -259,14 +259,19 @@ func (s *ProverTestSuite) TestContestWrongBlocks() {
 	s.Equal(header.Hash(), common.BytesToHash(contestedEvent.Tran.BlockHash[:]))
 	s.Equal(header.ParentHash, common.BytesToHash(contestedEvent.Tran.ParentHash[:]))
 
+	approvedSink := make(chan *bindings.GuardianProverApproved)
+	approvedSub, err := s.p.rpc.GuardianProver.WatchApproved(nil, approvedSink, []uint64{})
+	s.Nil(err)
+	defer func() {
+		approvedSub.Unsubscribe()
+		close(approvedSink)
+	}()
+
 	s.Nil(s.p.onTransitionContested(context.Background(), contestedEvent))
-	s.Nil(s.p.selectSubmitter(contestedEvent.Tier+1).SubmitProof(context.Background(), <-s.p.proofGenerationCh))
-	provenEvent := <-sink
+	s.Nil(s.p.selectSubmitter(encoding.TierGuardianID).SubmitProof(context.Background(), <-s.p.proofGenerationCh))
+	approvedEvent := <-approvedSink
 
-	s.Equal(header.Number.Uint64(), provenEvent.BlockId.Uint64())
-	s.Equal(header.Hash(), common.BytesToHash(provenEvent.Tran.BlockHash[:]))
-	s.Equal(header.ParentHash, common.BytesToHash(provenEvent.Tran.ParentHash[:]))
-	s.Greater(provenEvent.Tier, contestedEvent.Tier)
+	s.Equal(header.Number.Uint64(), approvedEvent.BlockId)
 }
 
 func (s *ProverTestSuite) TestProveExpiredUnassignedBlock() {

prover/server/api.go

@@ -180,7 +180,13 @@ func (srv *ProverServer) CreateAssignment(c echo.Context) error {
 		return echo.NewHTTPError(http.StatusUnprocessableEntity, "prover does not have capacity")
 	}
 
-	encoded, err := encoding.EncodeProverAssignmentPayload(req.TxListHash, req.FeeToken, req.Expiry, req.TierFees)
+	encoded, err := encoding.EncodeProverAssignmentPayload(
+		srv.taikoL1Address,
+		req.TxListHash,
+		req.FeeToken,
+		req.Expiry,
+		req.TierFees,
+	)
 	if err != nil {
 		log.Error("Failed to encode proverAssignment payload data", "error", err)
 		return echo.NewHTTPError(http.StatusUnprocessableEntity, err)

testutils/suite.go

@@ -102,7 +102,7 @@ func (s *ClientTestSuite) SetupTest() {
 		tx, err := addressManager.SetAddress(
 			opts,
 			chainID.Uint64(),
-			rpc.StringToBytes32("tier_pse_zkevm"),
+			rpc.StringToBytes32("tier_sgx_and_pse_zkevm"),
 			common.Address{},
 		)
 		s.Nil(err)