feat(taiko-client): client changes for ontake fork

packages/taiko-client/.golangci.yml

@@ -7,6 +7,7 @@ run:
   skip-files:
     - bindings/gen_taiko_l1.go
     - bindings/gen_taiko_l2.go
+    - bindings/encoding/struct.go
 
 issues:
   # List of regexps of issue texts to exclude.

packages/taiko-client/bindings/.githead

@@ -1 +1 @@
-c370c7e0976bbe1160b074be665d751410367d16
+32d96a816926e32da61f8495d257a8b10e26f83b

packages/taiko-client/bindings/encoding/input.go

@@ -8,6 +8,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/taikoxyz/taiko-mono/packages/taiko-client/bindings"
+	"github.com/taikoxyz/taiko-mono/packages/taiko-client/bindings/metadata"
 )
 
 // ABI arguments marshaling components.
@@ -70,6 +71,96 @@ var (
 			Type: "address",
 		},
 	}
+	blockMetadataV2Components = []abi.ArgumentMarshaling{
+		{
+			Name: "anchorBlockHash",
+			Type: "bytes32",
+		},
+		{
+			Name: "difficulty",
+			Type: "bytes32",
+		},
+		{
+			Name: "blobHash",
+			Type: "bytes32",
+		},
+		{
+			Name: "extraData",
+			Type: "bytes32",
+		},
+		{
+			Name: "coinbase",
+			Type: "address",
+		},
+		{
+			Name: "id",
+			Type: "uint64",
+		},
+		{
+			Name: "gasLimit",
+			Type: "uint32",
+		},
+		{
+			Name: "timestamp",
+			Type: "uint64",
+		},
+		{
+			Name: "anchorBlockId",
+			Type: "uint64",
+		},
+		{
+			Name: "minTier",
+			Type: "uint16",
+		},
+		{
+			Name: "blobUsed",
+			Type: "bool",
+		},
+		{
+			Name: "parentMetaHash",
+			Type: "bytes32",
+		},
+		{
+			Name: "proposer",
+			Type: "address",
+		},
+		{
+			Name: "livenessBond",
+			Type: "uint96",
+		},
+		{
+			Name: "proposedAt",
+			Type: "uint64",
+		},
+		{
+			Name: "proposedIn",
+			Type: "uint64",
+		},
+		{
+			Name: "blobTxListOffset",
+			Type: "uint32",
+		},
+		{
+			Name: "blobTxListLength",
+			Type: "uint32",
+		},
+		{
+			Name: "blobIndex",
+			Type: "uint8",
+		},
+		{
+			Name: "basefeeAdjustmentQuotient",
+			Type: "uint8",
+		},
+		{
+			Name: "basefeeSharingPctg",
+			Type: "uint8",
+		},
+		{
+			Name: "blockGasIssuance",
+			Type: "uint32",
+		},
+	}
 	transitionComponents = []abi.ArgumentMarshaling{
 		{
 			Name: "parentHash",
@@ -134,19 +225,61 @@ var (
 			Type: "bytes",
 		},
 	}
+	blockParamsV2Components = []abi.ArgumentMarshaling{
+		{
+			Name: "coinbase",
+			Type: "address",
+		},
+		{
+			Name: "extraData",
+			Type: "bytes32",
+		},
+		{
+			Name: "parentMetaHash",
+			Type: "bytes32",
+		},
+		{
+			Name: "anchorBlockId",
+			Type: "uint64",
+		},
+		{
+			Name: "timestamp",
+			Type: "uint64",
+		},
+		{
+			Name: "blobTxListOffset",
+			Type: "uint32",
+		},
+		{
+			Name: "blobTxListLength",
+			Type: "uint32",
+		},
+		{
+			Name: "blobIndex",
+			Type: "uint8",
+		},
+	}
 )
 
 var (
-	blockParamsComponentsType, _   = abi.NewType("tuple", "TaikoData.BlockParams", blockParamsComponents)
-	blockParamsComponentsArgs      = abi.Arguments{{Name: "TaikoData.BlockParams", Type: blockParamsComponentsType}}
-	blockMetadataComponentsType, _ = abi.NewType("tuple", "TaikoData.BlockMetadata", blockMetadataComponents)
-	transitionComponentsType, _    = abi.NewType("tuple", "TaikoData.Transition", transitionComponents)
-	tierProofComponentsType, _     = abi.NewType("tuple", "TaikoData.TierProof", tierProofComponents)
-	proveBlockInputArgs            = abi.Arguments{
+	blockParamsComponentsType, _     = abi.NewType("tuple", "TaikoData.BlockParams", blockParamsComponents)
+	blockParamsComponentsArgs        = abi.Arguments{{Name: "TaikoData.BlockParams", Type: blockParamsComponentsType}}
+	blockParamsV2ComponentsType, _   = abi.NewType("tuple", "TaikoData.BlockParamsV2", blockParamsV2Components)
+	blockParamsV2ComponentsArgs      = abi.Arguments{{Name: "TaikoData.BlockParamsV2", Type: blockParamsV2ComponentsType}}
+	blockMetadataComponentsType, _   = abi.NewType("tuple", "TaikoData.BlockMetadata", blockMetadataComponents)
+	blockMetadataV2ComponentsType, _ = abi.NewType("tuple", "TaikoData.BlockMetadataV2", blockMetadataV2Components)
+	transitionComponentsType, _      = abi.NewType("tuple", "TaikoData.Transition", transitionComponents)
+	tierProofComponentsType, _       = abi.NewType("tuple", "TaikoData.TierProof", tierProofComponents)
+	proveBlockInputArgs              = abi.Arguments{
 		{Name: "TaikoData.BlockMetadata", Type: blockMetadataComponentsType},
 		{Name: "TaikoData.Transition", Type: transitionComponentsType},
 		{Name: "TaikoData.TierProof", Type: tierProofComponentsType},
 	}
+	proveOntakeBlockInputArgs = abi.Arguments{
+		{Name: "TaikoData.BlockMetadataV2", Type: blockMetadataV2ComponentsType},
+		{Name: "TaikoData.Transition", Type: transitionComponentsType},
+		{Name: "TaikoData.TierProof", Type: tierProofComponentsType},
+	}
 )
 
 // Contract ABIs.
@@ -236,16 +369,43 @@ func EncodeBlockParams(params *BlockParams) ([]byte, error) {
 	return b, nil
 }
 
+// EncodeBlockParamsOntake performs the solidity `abi.encode` for the given ontake blockParams.
+func EncodeBlockParamsOntake(params *BlockParamsV2) ([]byte, error) {
+	b, err := blockParamsV2ComponentsArgs.Pack(params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to abi.encode ontake block params, %w", err)
+	}
+	return b, nil
+}
+
 // EncodeProveBlockInput performs the solidity `abi.encode` for the given TaikoL1.proveBlock input.
 func EncodeProveBlockInput(
-	meta *bindings.TaikoDataBlockMetadata,
+	meta metadata.TaikoBlockMetaData,
 	transition *bindings.TaikoDataTransition,
 	tierProof *bindings.TaikoDataTierProof,
 ) ([]byte, error) {
-	b, err := proveBlockInputArgs.Pack(meta, transition, tierProof)
-	if err != nil {
-		return nil, fmt.Errorf("failed to abi.encode TakoL1.proveBlock input, %w", err)
+	var (
+		b   []byte
+		err error
+	)
+	if meta.IsOntakeBlock() {
+		if b, err = proveOntakeBlockInputArgs.Pack(
+			meta.(*metadata.TaikoDataBlockMetadataOntake).InnerMetadata(),
+			transition,
+			tierProof,
+		); err != nil {
+			return nil, fmt.Errorf("failed to abi.encode TakoL1.proveBlock input after ontake fork, %w", err)
+		}
+	} else {
+		if b, err = proveBlockInputArgs.Pack(
+			meta.(*metadata.TaikoDataBlockMetadataLegacy).InnerMetadata(),
+			transition,
+			tierProof,
+		); err != nil {
+			return nil, fmt.Errorf("failed to abi.encode TakoL1.proveBlock input, %w", err)
+		}
 	}
+
 	return b, nil
 }
 

packages/taiko-client/bindings/encoding/protocol_config.go

@@ -0,0 +1,67 @@
+package encoding
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/params"
+
+	"github.com/taikoxyz/taiko-mono/packages/taiko-client/bindings"
+)
+
+var (
+	livenessBond, _             = new(big.Int).SetString("125000000000000000000", 10)
+	InternlDevnetProtocolConfig = &bindings.TaikoDataConfig{
+		ChainId:                   params.TaikoInternalL2ANetworkID.Uint64(),
+		BlockMaxProposals:         324_000,
+		BlockRingBufferSize:       360_000,
+		MaxBlocksToVerify:         16,
+		BlockMaxGasLimit:          240_000_000,
+		LivenessBond:              livenessBond,
+		StateRootSyncInternal:     16,
+		MaxAnchorHeightOffset:     64,
+		BasefeeAdjustmentQuotient: 8,
+		BasefeeSharingPctg:        75,
+		BlockGasIssuance:          20_000_000,
+		OntakeForkHeight:          374_400,
+	}
+	HeklaProtocolConfig = &bindings.TaikoDataConfig{
+		ChainId:                   params.HeklaNetworkID.Uint64(),
+		BlockMaxProposals:         324_000,
+		BlockRingBufferSize:       324_512,
+		MaxBlocksToVerify:         16,
+		BlockMaxGasLimit:          240_000_000,
+		LivenessBond:              livenessBond,
+		StateRootSyncInternal:     16,
+		MaxAnchorHeightOffset:     64,
+		BasefeeAdjustmentQuotient: 8,
+		BasefeeSharingPctg:        75,
+		BlockGasIssuance:          20_000_000,
+		OntakeForkHeight:          540_000,
+	}
+	MainnetProtocolConfig = &bindings.TaikoDataConfig{
+		ChainId:                   params.TaikoMainnetNetworkID.Uint64(),
+		BlockMaxProposals:         324_000,
+		BlockRingBufferSize:       360_000,
+		MaxBlocksToVerify:         16,
+		BlockMaxGasLimit:          240_000_000,
+		LivenessBond:              livenessBond,
+		StateRootSyncInternal:     16,
+		MaxAnchorHeightOffset:     64,
+		BasefeeAdjustmentQuotient: 8,
+		BasefeeSharingPctg:        75,
+		BlockGasIssuance:          20_000_000,
+		OntakeForkHeight:          374_400,
+	}
+)
+
+// GetProtocolConfig returns the protocol config for the given chain ID.
+func GetProtocolConfig(chainID uint64) *bindings.TaikoDataConfig {
+	switch chainID {
+	case params.HeklaNetworkID.Uint64():
+		return HeklaProtocolConfig
+	case params.TaikoMainnetNetworkID.Uint64():
+		return MainnetProtocolConfig
+	default:
+		return InternlDevnetProtocolConfig
+	}
+}

packages/taiko-client/bindings/encoding/struct.go

@@ -6,6 +6,8 @@ import (
 	"github.com/ethereum/go-ethereum/beacon/engine"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/taikoxyz/taiko-mono/packages/taiko-client/bindings"
 )
 
 // Tier IDs defined in protocol.
@@ -41,6 +43,18 @@ type BlockParams struct {
 	Signature      []byte
 }
 
+// BlockParamsV2 should be same with TaikoData.BlockParamsV2.
+type BlockParamsV2 struct {
+	Coinbase         common.Address
+	ExtraData        [32]byte
+	ParentMetaHash   [32]byte
+	AnchorBlockId    uint64
+	Timestamp        uint64
+	BlobTxListOffset uint32
+	BlobTxListLength uint32
+	BlobIndex        uint8
+}
+
 // TierFee should be same with TaikoData.TierFee.
 type TierFee struct {
 	Tier uint16
@@ -73,6 +87,51 @@ func ToExecutableData(header *types.Header) *engine.ExecutableData {
 	return executableData
 }
 
+// TransitionProvedEventToV2 converts a *bindings.TaikoL1ClientTransitionProved
+// to *bindings.TaikoL1ClientTransitionProvedV2.
+func TransitionProvedEventToV2(
+	e *bindings.TaikoL1ClientTransitionProved,
+	proposedIn uint64,
+) *bindings.TaikoL1ClientTransitionProvedV2 {
+	return &bindings.TaikoL1ClientTransitionProvedV2{
+		BlockId:      e.BlockId,
+		Tran:         e.Tran,
+		Prover:       e.Prover,
+		ValidityBond: e.ValidityBond,
+		Tier:         e.Tier,
+		ProposedIn:   proposedIn,
+		Raw:          e.Raw,
+	}
+}
+
+// TransitionContestedEventToV2 converts a *bindings.TaikoL1ClientTransitionContested
+// to *bindings.TaikoL1ClientTransitionContestedV2.
+func TransitionContestedEventToV2(
+	e *bindings.TaikoL1ClientTransitionContested,
+	proposedIn uint64,
+) *bindings.TaikoL1ClientTransitionContestedV2 {
+	return &bindings.TaikoL1ClientTransitionContestedV2{
+		BlockId:     e.BlockId,
+		Tran:        e.Tran,
+		Contester:   e.Contester,
+		ContestBond: e.ContestBond,
+		Tier:        e.Tier,
+		ProposedIn:  proposedIn,
+		Raw:         e.Raw,
+	}
+}
+
+// BlockVerifiedEventToV2 converts a *bindings.TaikoL1ClientBlockVerified to *bindings.TaikoL1ClientBlockVerifiedV2.
+func BlockVerifiedEventToV2(e *bindings.TaikoL1ClientBlockVerified) *bindings.TaikoL1ClientBlockVerifiedV2 {
+	return &bindings.TaikoL1ClientBlockVerifiedV2{
+		BlockId:   e.BlockId,
+		Prover:    e.Prover,
+		BlockHash: e.BlockHash,
+		Tier:      e.Tier,
+		Raw:       e.Raw,
+	}
+}
+
 // BloomToBytes converts a types.Bloom to [8][32]byte slice.
 func BloomToBytes(bloom types.Bloom) [8][32]byte {
 	b := [8][32]byte{}