test(prover): rename some variables

pkg/rpc/utils.go

@@ -45,7 +45,7 @@ func CheckProverBalance(
 	rpc *Client,
 	prover common.Address,
 	taikoL1Address common.Address,
-	bond *big.Int,
+	livenessBond *big.Int,
 ) (bool, error) {
 	ctxWithTimeout, cancel := ctxWithTimeoutOrDefault(ctx, defaultTimeout)
 	defer cancel()
@@ -57,7 +57,7 @@ func CheckProverBalance(
 
 	log.Info("Prover's deposited taikoTokenBalance", "balance", depositedBalance.String(), "address", prover.Hex())
 
-	if bond.Cmp(depositedBalance) > 0 {
+	if livenessBond.Cmp(depositedBalance) > 0 {
 		// Check allowance on taiko token contract
 		allowance, err := rpc.TaikoToken.Allowance(&bind.CallOpts{Context: ctxWithTimeout}, prover, taikoL1Address)
 		if err != nil {
@@ -74,14 +74,14 @@ func CheckProverBalance(
 
 		log.Info("Prover's wallet taiko token balance", "balance", balance.String(), "address", prover.Hex())
 
-		if bond.Cmp(allowance) > 0 || bond.Cmp(balance) > 0 {
+		if livenessBond.Cmp(allowance) > 0 || livenessBond.Cmp(balance) > 0 {
 			log.Info(
 				"Assigned prover does not have required on-chain token balance or allowance",
 				"providedProver", prover.Hex(),
 				"depositedBalance", depositedBalance.String(),
 				"taikoTokenBalance", balance,
 				"allowance", allowance.String(),
-				"proofBond", bond,
+				"proofBond", livenessBond,
 			)
 			return false, nil
 		}

prover/prover.go

@@ -206,7 +206,7 @@ func InitFromConfig(ctx context.Context, p *Prover, cfg *Config) (err error) {
 		CapacityManager:      p.capacityManager,
 		TaikoL1Address:       p.cfg.TaikoL1Address,
 		Rpc:                  p.rpc,
-		Bond:                 protocolConfigs.LivenessBond,
+		LivenessBond:         protocolConfigs.LivenessBond,
 		IsGuardian:           p.cfg.GuardianProver,
 	}
 	if p.cfg.GuardianProver {
@@ -667,25 +667,36 @@ func (p *Prover) closeSubscription() {
 // isValidProof checks if the given proof is a valid one.
 func (p *Prover) isValidProof(
 	ctx context.Context,
-	blockID uint64,
-	parentHash common.Hash,
-	blockHash common.Hash,
+	event *bindings.TaikoL1ClientTransitionProved,
 ) (bool, error) {
-	parent, err := p.rpc.L2ParentByBlockId(ctx, new(big.Int).SetUint64(blockID))
+	parent, err := p.rpc.L2ParentByBlockId(ctx, event.BlockId)
 	if err != nil {
 		return false, err
 	}
 
-	block, err := p.rpc.L2.BlockByNumber(ctx, new(big.Int).SetUint64(blockID))
+	block, err := p.rpc.L2.BlockByNumber(ctx, event.BlockId)
 	if err != nil {
 		return false, err
 	}
 
-	if parent.Hash() == parentHash && blockHash == block.Hash() {
-		return true, nil
+	l2SignalService, err := p.rpc.TaikoL2.Resolve0(nil, rpc.StringToBytes32("signal_service"), false)
+	if err != nil {
+		return false, err
+	}
+
+	signalRoot, err := p.rpc.GetStorageRoot(
+		ctx,
+		p.rpc.L2GethClient,
+		l2SignalService,
+		event.BlockId,
+	)
+	if err != nil {
+		return false, err
 	}
 
-	return false, nil
+	return parent.Hash() == event.ParentHash &&
+		block.Hash() == event.BlockHash &&
+		signalRoot == event.SignalRoot, nil
 }
 
 // onTransitionProved verifies the proven block hash and will try contesting it if the block hash is wrong.
@@ -709,12 +720,9 @@ func (p *Prover) onTransitionProved(ctx context.Context, event *bindings.TaikoL1
 		return nil
 	}
 
-	// TODO(david): check signalRoot
 	isValidProof, err := p.isValidProof(
 		ctx,
-		event.BlockId.Uint64(),
-		event.ParentHash,
-		event.BlockHash,
+		event,
 	)
 	if err != nil {
 		return err

prover/server/api.go

@@ -94,8 +94,13 @@ func (srv *ProverServer) CreateAssignment(c echo.Context) error {
 	}
 
 	if !srv.isGuardian {
-		// TODO: use tier bond
-		ok, err := rpc.CheckProverBalance(c.Request().Context(), srv.rpc, srv.proverAddress, srv.taikoL1Address, srv.bond)
+		ok, err := rpc.CheckProverBalance(
+			c.Request().Context(),
+			srv.rpc,
+			srv.proverAddress,
+			srv.taikoL1Address,
+			srv.livenessBond,
+		)
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, err)
 		}

prover/server/server.go

@@ -40,7 +40,7 @@ type ProverServer struct {
 	capacityManager      *capacity.CapacityManager
 	taikoL1Address       common.Address
 	rpc                  *rpc.Client
-	bond                 *big.Int
+	livenessBond         *big.Int
 	isGuardian           bool
 }
 
@@ -54,7 +54,7 @@ type NewProverServerOpts struct {
 	CapacityManager      *capacity.CapacityManager
 	TaikoL1Address       common.Address
 	Rpc                  *rpc.Client
-	Bond                 *big.Int
+	LivenessBond         *big.Int
 	IsGuardian           bool
 }
 
@@ -71,7 +71,7 @@ func New(opts *NewProverServerOpts) (*ProverServer, error) {
 		capacityManager:      opts.CapacityManager,
 		taikoL1Address:       opts.TaikoL1Address,
 		rpc:                  opts.Rpc,
-		bond:                 opts.Bond,
+		livenessBond:         opts.LivenessBond,
 		isGuardian:           opts.IsGuardian,
 	}
 

prover/server/server_test.go

@@ -54,7 +54,7 @@ func (s *ProverServerTestSuite) SetupTest() {
 		CapacityManager:      capacity.New(1024),
 		TaikoL1Address:       common.HexToAddress(os.Getenv("TAIKO_L1_ADDRESS")),
 		Rpc:                  rpcClient,
-		Bond:                 common.Big0,
+		LivenessBond:         common.Big0,
 		IsGuardian:           false,
 	})
 	s.Nil(err)

testutils/helper.go

@@ -190,7 +190,7 @@ func NewTestProverServer(
 		CapacityManager:      capacityManager,
 		TaikoL1Address:       common.HexToAddress(os.Getenv("TAIKO_L1_ADDRESS")),
 		Rpc:                  s.RpcClient,
-		Bond:                 protocolConfig.LivenessBond,
+		LivenessBond:         protocolConfig.LivenessBond,
 		IsGuardian:           true,
 	})
 	s.Nil(err)