feat(prover): guardian prover block signature && bindings updates for…

… based contestable zkRollup (#450)

Co-authored-by: Roger <50648015+RogerLamTd@users.noreply.github.com>

.github/workflows/test.yml

@@ -45,7 +45,7 @@ jobs:
         with:
           repository: taikoxyz/taiko-mono
           path: ${{ env.TAIKO_MONO_DIR }}
-          ref: bridgable_app
+          ref: update_relayer_eventindexer_post_hooks
 
       - name: Install Foundry
         uses: foundry-rs/foundry-toolchain@v1

.gitignore

@@ -6,6 +6,7 @@
 *.dylib
 bin
 coverage.out
+prover/dbPath
 
 # Test binary, built with `go test -c`
 *.test

bindings/.githead

@@ -1 +1 @@
-205eb2c49f2364ffe382408577040767a69c5a03
+8a27392aead6350fd00d8add2ab0a459808e6160

bindings/encoding/custom_error.go

@@ -11,6 +11,11 @@ import (
 func TryParsingCustomError(originalError error) error {
 	errData := getErrorData(originalError)
 
+	// if errData is unparsable and returns 0x, we should not match any errors.
+	if errData == "0x" {
+		return originalError
+	}
+
 	for _, l1CustomError := range TaikoL1ABI.Errors {
 		if strings.HasPrefix(l1CustomError.ID.Hex(), errData) {
 			return errors.New(l1CustomError.Name)

bindings/encoding/custom_error_test.go

@@ -15,6 +15,12 @@ func (e *testJsonError) Error() string { return common.Bytes2Hex(randomBytes(10)
 
 func (e *testJsonError) ErrorData() interface{} { return "0x8a1c400f" }
 
+type emptyTestJsonError struct{}
+
+func (e *emptyTestJsonError) Error() string { return "execution reverted" }
+
+func (e *emptyTestJsonError) ErrorData() interface{} { return "0x" }
+
 func TestTryParsingCustomError(t *testing.T) {
 	randomErr := common.Bytes2Hex(randomBytes(10))
 	require.Equal(t, randomErr, TryParsingCustomError(errors.New(randomErr)).Error())
@@ -29,4 +35,8 @@ func TestTryParsingCustomError(t *testing.T) {
 	err = TryParsingCustomError(&testJsonError{})
 
 	require.True(t, strings.HasPrefix(err.Error(), "L1_INVALID_BLOCK_ID"))
+
+	err = TryParsingCustomError(&emptyTestJsonError{})
+
+	require.Equal(t, err.Error(), "execution reverted")
 }

bindings/encoding/input.go

@@ -69,6 +69,10 @@ var (
 			Name: "blobUsed",
 			Type: "bool",
 		},
+		{
+			Name: "parentMetaHash",
+			Type: "bytes32",
+		},
 	}
 	transitionComponents = []abi.ArgumentMarshaling{
 		{
@@ -100,9 +104,8 @@ var (
 	}
 	blockParamsComponents = []abi.ArgumentMarshaling{
 		{
-			Name:       "assignment",
-			Type:       "tuple",
-			Components: proverAssignmentComponents,
+			Name: "assignedProver",
+			Type: "address",
 		},
 		{
 			Name: "extraData",
@@ -124,15 +127,45 @@ var (
 			Name: "cacheBlobForReuse",
 			Type: "bool",
 		},
+		{
+			Name: "parentMetaHash",
+			Type: "bytes32",
+		},
+		{
+			Name: "hookCalls",
+			Type: "tuple[]",
+			Components: []abi.ArgumentMarshaling{
+				{
+					Name: "hook",
+					Type: "address",
+				},
+				{
+					Name: "data",
+					Type: "bytes",
+				},
+			},
+		},
 	}
 	proverAssignmentComponents = []abi.ArgumentMarshaling{
 		{
-			Name: "prover",
+			Name: "feeToken",
 			Type: "address",
 		},
 		{
-			Name: "feeToken",
-			Type: "address",
+			Name: "expiry",
+			Type: "uint64",
+		},
+		{
+			Name: "maxBlockId",
+			Type: "uint64",
+		},
+		{
+			Name: "maxProposedIn",
+			Type: "uint64",
+		},
+		{
+			Name: "metaHash",
+			Type: "bytes32",
 		},
 		{
 			Name: "tierFees",
@@ -149,22 +182,27 @@ var (
 			},
 		},
 		{
-			Name: "expiry",
-			Type: "uint64",
+			Name: "signature",
+			Type: "bytes",
 		},
+	}
+	assignmentHookInputComponents = []abi.ArgumentMarshaling{
 		{
-			Name: "maxBlockId",
-			Type: "uint64",
+			Name:       "assignment",
+			Type:       "tuple",
+			Components: proverAssignmentComponents,
 		},
 		{
-			Name: "signature",
-			Type: "bytes",
+			Name: "tip",
+			Type: "uint256",
 		},
 	}
 )
 
 var (
 	// BlockParams
+	assignmentHookInputType, _   = abi.NewType("tuple", "AssignmentHook.Input", assignmentHookInputComponents)
+	assignmentHookInputArgs      = abi.Arguments{{Name: "AssignmentHook.Input", Type: assignmentHookInputType}}
 	blockParamsComponentsType, _ = abi.NewType("tuple", "TaikoData.BlockParams", blockParamsComponents)
 	blockParamsComponentsArgs    = abi.Arguments{{Name: "TaikoData.BlockParams", Type: blockParamsComponentsType}}
 	// ProverAssignmentPayload
@@ -193,6 +231,7 @@ var (
 		{Name: "assignment.feeToken", Type: addressType},
 		{Name: "assignment.expiry", Type: uint64Type},
 		{Name: "assignment.maxBlockId", Type: uint64Type},
+		{Name: "assignment.maxProposedIn", Type: uint64Type},
 		{Name: "assignment.tierFees", Type: tierFeesType},
 	}
 	blockMetadataComponentsType, _ = abi.NewType("tuple", "TaikoData.BlockMetadata", blockMetadataComponents)
@@ -232,13 +271,23 @@ func EncodeBlockParams(params *BlockParams) ([]byte, error) {
 	return b, nil
 }
 
+// EncodeAssignmentHookInput performs the solidity `abi.encode` for the given input
+func EncodeAssignmentHookInput(input *AssignmentHookInput) ([]byte, error) {
+	b, err := assignmentHookInputArgs.Pack(input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to abi.encode assignment hook input params, %w", err)
+	}
+	return b, nil
+}
+
 // EncodeProverAssignmentPayload performs the solidity `abi.encode` for the given proverAssignment payload.
 func EncodeProverAssignmentPayload(
 	taikoAddress common.Address,
 	txListHash common.Hash,
 	feeToken common.Address,
 	expiry uint64,
 	maxBlockID uint64,
+	maxProposedIn uint64,
 	tierFees []TierFee,
 ) ([]byte, error) {
 	b, err := proverAssignmentPayloadArgs.Pack(
@@ -248,6 +297,7 @@ func EncodeProverAssignmentPayload(
 		feeToken,
 		expiry,
 		maxBlockID,
+		maxProposedIn,
 		tierFees,
 	)
 	if err != nil {

bindings/encoding/input_test.go

@@ -2,6 +2,7 @@ package encoding
 
 import (
 	"context"
+	"math/big"
 	"os"
 	"testing"
 
@@ -22,13 +23,32 @@ func TestEncodeProverAssignmentPayload(t *testing.T) {
 		common.BytesToAddress(randomBytes(20)),
 		120,
 		1024,
+		0,
 		[]TierFee{{Tier: 0, Fee: common.Big1}},
 	)
 
 	require.Nil(t, err)
 	require.NotNil(t, encoded)
 }
 
+func TestEncodeAssignmentHookInput(t *testing.T) {
+	encoded, err := EncodeAssignmentHookInput(&AssignmentHookInput{
+		Assignment: &ProverAssignment{
+			FeeToken:      common.Address{},
+			Expiry:        1,
+			MaxBlockId:    1,
+			MaxProposedIn: 1,
+			MetaHash:      [32]byte{0xff},
+			TierFees:      []TierFee{{Tier: 0, Fee: common.Big1}},
+			Signature:     []byte{0xff},
+		},
+		Tip: big.NewInt(1),
+	})
+
+	require.Nil(t, err)
+	require.NotNil(t, encoded)
+}
+
 func TestUnpackTxListBytes(t *testing.T) {
 	_, err := UnpackTxListBytes(randomBytes(1024))
 	require.NotNil(t, err)

bindings/encoding/struct.go

@@ -38,14 +38,22 @@ type BlockHeader struct {
 	BaseFeePerGas    *big.Int
 }
 
+// HookCall should be same with TaikoData.HookCall
+type HookCall struct {
+	Hook common.Address
+	Data []byte
+}
+
 // BlockParams should be same with TaikoData.BlockParams.
 type BlockParams struct {
-	Assignment        *ProverAssignment
+	AssignedProver    common.Address
 	ExtraData         [32]byte
 	BlobHash          [32]byte
 	TxListByteOffset  *big.Int
 	TxListByteSize    *big.Int
 	CacheBlobForReuse bool
+	ParentMetaHash    [32]byte
+	HookCalls         []HookCall
 }
 
 // TierFee should be same with TaikoData.TierFee.
@@ -56,12 +64,19 @@ type TierFee struct {
 
 // ProverAssignment should be same with TaikoData.ProverAssignment.
 type ProverAssignment struct {
-	Prover     common.Address
-	FeeToken   common.Address
-	TierFees   []TierFee
-	Expiry     uint64
-	MaxBlockId uint64
-	Signature  []byte
+	FeeToken      common.Address
+	Expiry        uint64
+	MaxBlockId    uint64
+	MaxProposedIn uint64
+	MetaHash      [32]byte
+	TierFees      []TierFee
+	Signature     []byte
+}
+
+// AssignmentHookInput should be same as AssignmentHook.Input
+type AssignmentHookInput struct {
+	Assignment *ProverAssignment
+	Tip        *big.Int
 }
 
 // FromGethHeader converts a GETH *types.Header to *BlockHeader.