Allow block processing to continue with failed rollups

contracts/src/management/ManagementContract.sol

@@ -25,7 +25,7 @@ contract ManagementContract is Initializable, OwnableUpgradeable {
     event ImportantContractAddressUpdated(string key, address newAddress);
     event SequencerEnclaveGranted(address enclaveID);
     event SequencerEnclaveRevoked(address enclaveID);
-    event RollupAdded(bytes32 rollupHash);
+    event RollupAdded(bytes32 rollupHash, bytes signature);
     event NetworkSecretRequested(address indexed requester, string requestReport);
     event NetworkSecretResponded(address indexed attester, address indexed requester);
 
@@ -110,18 +110,17 @@ contract ManagementContract is Initializable, OwnableUpgradeable {
 
         require(knownBlockHash != 0x0, "Unknown block hash");
         require(knownBlockHash == r.BlockBindingHash, "Block binding mismatch");
+        require(blobhash(0) != bytes32(0), "Blob hash is not set");
 
         bytes32 compositeHash = keccak256(abi.encodePacked(
             r.LastSequenceNumber,
+            r.LastBatchHash,
             r.BlockBindingHash,
             r.BlockBindingNumber,
             r.crossChainRoot,
-            r.BlobHash
+            blobhash(0)
         ));
 
-        // Verify the hash matches the one in the rollup
-        require(compositeHash == r.CompositeHash, "Composite hash mismatch");
-
         // Verify the enclave signature
         address enclaveID = ECDSA.recover(compositeHash, r.Signature);
         require(attested[enclaveID], "enclaveID not attested");
@@ -136,9 +135,11 @@ contract ManagementContract is Initializable, OwnableUpgradeable {
         if (r.crossChainRoot != bytes32(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
             merkleMessageBus.addStateRoot(r.crossChainRoot, block.timestamp);
         }
-        emit RollupAdded(r.Hash);
+
+        emit RollupAdded(blobhash(0), r.Signature);
     }
 
+
     // InitializeNetworkSecret kickstarts the network secret, can only be called once
     // solc-ignore-next-line unused-param
     function InitializeNetworkSecret(address _enclaveID, bytes calldata  _initSecret, string calldata _genesisAttestation) public {

contracts/src/management/Structs.sol

@@ -6,14 +6,13 @@ import * as MessageBusStructs from "../messaging/Structs.sol";
 interface Structs {
     struct MetaRollup{
         bytes32 Hash;
-        bytes Signature;
         uint256 LastSequenceNumber;
 
         bytes32 BlockBindingHash;
         uint256 BlockBindingNumber;
         bytes32 crossChainRoot;
-        bytes32 BlobHash;
-        bytes32 CompositeHash;
+        bytes32 LastBatchHash;
+        bytes Signature;
     }
 
     struct RollupStorage {

go/common/enclave.go

@@ -95,8 +95,8 @@ type EnclaveAdmin interface {
 	CreateBatch(ctx context.Context, skipIfEmpty bool) SystemError
 
 	// CreateRollup - will create a new rollup by going through the sequencer if the node is a sequencer
-	// or panic otherwise.
-	CreateRollup(ctx context.Context, fromSeqNo uint64) (*ExtRollup, []*kzg4844.Blob, SystemError)
+	// or panic otherwise. Returns the rollup data including signature and blobs.
+	CreateRollup(ctx context.Context, fromSeqNo uint64) (*CreateRollupResult, SystemError)
 
 	// StreamL2Updates - will stream any new batches as they are created/detected
 	// All will be queued in the channel that has been returned.

go/common/errutil/errors_util.go

@@ -19,15 +19,13 @@ var (
 
 	// Standard errors that can be returned from block submission
 
-	ErrBlockAlreadyProcessed       = errors.New("block already processed")
-	ErrBlockAncestorNotFound       = errors.New("block ancestor not found")
-	ErrBlockForBatchNotFound       = errors.New("block for batch not found")
-	ErrAncestorBatchNotFound       = errors.New("parent for batch not found")
-	ErrCrossChainBundleRepublished = errors.New("root already added to the message bus")
-	ErrCrossChainBundleNoBatches   = errors.New("no batches for cross chain bundle")
-	ErrNoNextRollup                = errors.New("no next rollup")
-	ErrRollupForkMismatch          = errors.New("rollup fork mismatch")
-	ErrCrossChainRootMismatch      = errors.New("cross chain root mismatch")
+	ErrBlockAlreadyProcessed     = errors.New("block already processed")
+	ErrBlockAncestorNotFound     = errors.New("block ancestor not found")
+	ErrBlockForBatchNotFound     = errors.New("block for batch not found")
+	ErrAncestorBatchNotFound     = errors.New("parent for batch not found")
+	ErrCrossChainBundleNoBatches = errors.New("no batches for cross chain bundle")
+	ErrCrossChainRootMismatch    = errors.New("cross chain root mismatch")
+	ErrCriticalRollupProcessing  = errors.New("critical error during rollup processing")
 )
 
 // BlockRejectError is used as a standard format for error response from enclave for block submission errors

go/common/headers.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto/kzg4844"
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/rlp"
@@ -168,10 +169,55 @@ type RollupHeader struct {
 
 	CrossChainRoot common.Hash // The root hash of the cross chain tree.
 	LastBatchSeqNo uint64
-	BlobHash       common.Hash
-	CompositeHash  common.Hash // composite of everything
+	LastBatchHash  common.Hash
+}
 
-	Signature []byte // The signature of the sequencer enclave over the composite hash
+// ComputeCompositeHash creates a composite hash matching the contract's expectations.
+// It takes the last batch sequence number, current L1 hash and number, cross-chain root, and blob hash as inputs.
+func ComputeCompositeHash(
+	header *RollupHeader,
+	blobHash common.Hash,
+) common.Hash {
+	return crypto.Keccak256Hash(
+		common.LeftPadBytes(new(big.Int).SetUint64(header.LastBatchSeqNo).Bytes(), 32),
+		header.LastBatchHash.Bytes(),
+		header.CompressionL1Head.Bytes(),
+		common.LeftPadBytes(header.CompressionL1Number.Bytes(), 32),
+		header.CrossChainRoot.Bytes(),
+		blobHash.Bytes(),
+	)
+}
+
+const BlobVersion byte = 0x01
+
+// DeriveBlobHash computes the versioned blob hash for the given blob.
+// If blob is nil (or otherwise considered "non-existent"), it returns the zero hash.
+func DeriveBlobHash(blob *kzg4844.Blob) (common.Hash, error) {
+	// If the blob doesn't exist, return the zero hash.
+	if blob == nil {
+		return common.Hash{}, nil
+	}
+
+	// Compute the KZG commitment for the blob.
+	// Adjust the function name and signature to match your KZG library.
+	commitment, err := kzg4844.BlobToCommitment(blob)
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("failed to compute KZG commitment: %w", err)
+	}
+
+	// Serialize the commitment.
+	commitmentBytes := commitment[:31] // Expecting, for example, 48 bytes.
+
+	// Prepend the version byte.
+	// Create a new slice with capacity 1 + len(commitmentBytes).
+	versioned := make([]byte, 0, 1+len(commitmentBytes))
+	versioned = append(versioned, BlobVersion)
+	versioned = append(versioned, commitmentBytes...)
+
+	// Compute the Keccak-256 hash of the versioned commitment.
+	blobHash := crypto.Keccak256Hash(versioned)
+
+	return blobHash, nil
 }
 
 // CalldataRollupHeader contains all information necessary to reconstruct the batches included in the rollup.
@@ -231,7 +277,6 @@ func (b *BatchHeader) Hash() L2BatchHash {
 // RLP encoding excluding the signature.
 func (r *RollupHeader) Hash() L2RollupHash {
 	cp := *r
-	cp.Signature = nil
 	hash, err := rlpHash(cp)
 	if err != nil {
 		panic("err hashing rollup header")

go/common/host/services.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/crypto/kzg4844"
-
 	"github.com/ten-protocol/go-ten/go/host/storage"
 
 	"github.com/ten-protocol/go-ten/go/responses"
@@ -109,7 +107,7 @@ type L1Publisher interface {
 	FindSecretResponseTx(responseTxs []*common.L1TxData) []*common.L1RespondSecretTx
 	// PublishBlob will create and publish a rollup tx to the management contract - fire and forget we don't wait for receipt
 	// todo (#1624) - With a single sequencer, it is problematic if rollup publication fails; handle this case better
-	PublishBlob(producedRollup *common.ExtRollup, blobs []*kzg4844.Blob)
+	PublishBlob(result common.CreateRollupResult)
 	// PublishSecretResponse will create and publish a secret response tx to the management contract - fire and forget we don't wait for receipt
 	PublishSecretResponse(secretResponse *common.ProducedSecretResponse) error
 

go/common/l1_transaction.go

@@ -81,15 +81,32 @@ type L1Event struct {
 	Txs  []*L1TxData
 }
 
+type BlobAndSignature struct {
+	Blob      *kzg4844.Blob
+	Signature RollupSignature
+}
+
+type BlobsAndSignatures []BlobAndSignature
+
+func (b *BlobsAndSignatures) ToBlobs() []*kzg4844.Blob {
+	blobs := make([]*kzg4844.Blob, len(*b))
+	for i, blob := range *b {
+		blobs[i] = blob.Blob
+	}
+	return blobs
+}
+
 // L1TxData represents an L1 transaction that are relevant to us
 type L1TxData struct {
 	Transaction        *types.Transaction
 	Receipt            *types.Receipt
-	Blobs              []*kzg4844.Blob     // Only populated for blob transactions
+	Blobs              []*kzg4844.Blob // Only populated for blob transactions
+	BlobsWithSignature BlobsAndSignatures
 	SequencerEnclaveID gethcommon.Address  // Only non-zero when a new enclave is added as a sequencer
 	CrossChainMessages CrossChainMessages  // Only populated for xchain messages
 	ValueTransfers     ValueTransferEvents // Only populated for xchain transfers
-	Proof              []byte              // Some merkle proof TBC
+
+	Proof []byte // Some merkle proof TBC
 }
 
 // HasSequencerEnclaveID helper method to check if SequencerEnclaveID is set to avoid custom RLP when we send over grpc
@@ -139,3 +156,17 @@ func (p *ProcessedL1Data) GetEvents(txType L1TenEventType) []*L1TxData {
 	}
 	return nil
 }
+
+func (p *ProcessedL1Data) HasEvents(tenEventType L1TenEventType) bool {
+	if p == nil || len(p.Events) == 0 {
+		return false
+	}
+
+	for _, event := range p.Events {
+		if event.Type == uint8(tenEventType) && len(event.Txs) > 0 {
+			return true
+		}
+	}
+
+	return false
+}

go/common/rpc/converters.go

@@ -210,12 +210,10 @@ func ToRollupHeaderMsg(header *common.RollupHeader) *generated.RollupHeaderMsg {
 	}
 	headerMsg := generated.RollupHeaderMsg{
 		CompressionL1Head:   header.CompressionL1Head.Bytes(),
-		Signature:           header.Signature,
-		LastBatchSeqNo:      header.LastBatchSeqNo,
-		CrossChainRoot:      header.CrossChainRoot.Bytes(),
 		CompressionL1Number: header.CompressionL1Number.Bytes(),
-		BlobHash:            header.BlobHash.Bytes(),
-		CompositeHash:       header.CompositeHash.Bytes(),
+		CrossChainRoot:      header.CrossChainRoot.Bytes(),
+		LastBatchSeqNo:      header.LastBatchSeqNo,
+		LastBatchHash:       header.LastBatchHash.Bytes(),
 	}
 
 	return &headerMsg
@@ -245,9 +243,7 @@ func FromRollupHeaderMsg(header *generated.RollupHeaderMsg) *common.RollupHeader
 		CompressionL1Number: big.NewInt(0).SetBytes(header.CompressionL1Number),
 		CrossChainRoot:      gethcommon.BytesToHash(header.CrossChainRoot),
 		LastBatchSeqNo:      header.LastBatchSeqNo,
-		Signature:           header.Signature,
-		BlobHash:            gethcommon.BytesToHash(header.BlobHash),
-		CompositeHash:       gethcommon.BytesToHash(header.CompositeHash),
+		LastBatchHash:       gethcommon.BytesToHash(header.LastBatchHash),
 	}
 }
 
@@ -289,3 +285,16 @@ func ToBlobMsgs(blobs []*kzg4844.Blob) []*generated.BlobMsg {
 	}
 	return msgs
 }
+
+func FromBlobMsgs(msgs []*generated.BlobMsg) []*kzg4844.Blob {
+	if msgs == nil {
+		return nil
+	}
+	blobs := make([]*kzg4844.Blob, len(msgs))
+	for i, msg := range msgs {
+		var blob kzg4844.Blob
+		copy(blob[:], msg.Blob)
+		blobs[i] = &blob
+	}
+	return blobs
+}