Merge pull request #139 from Layr-Labs/kira--rebase-v3.8.0-rc.16

Rebase and merge upstream with v3.8.0-rc.16

Author: shyam-patel-kira

.github/workflows/nightly-ci.yml

@@ -69,7 +69,7 @@ jobs:
       - name: Lint
         uses: golangci/golangci-lint-action@v8
         with:
-          version: latest
+          version: v2.5
           skip-cache: true
           skip-save-cache: true
 

Dockerfile

@@ -115,7 +115,7 @@ WORKDIR /workspace
 RUN export DEBIAN_FRONTEND=noninteractive && \
     apt-get update && \
     apt-get install -y make clang wabt && \
-    cargo install --force cbindgen
+    cargo install --force cbindgen --version 0.24.3
 COPY arbitrator/Cargo.* arbitrator/
 COPY ./Makefile ./
 COPY arbitrator/arbutil arbitrator/arbutil

arbnode/dataposter/data_poster.go

@@ -258,11 +258,13 @@ func TxToSignTxArgs(addr common.Address, tx *types.Transaction) (*apitypes.SendT
 		blobs       []kzg4844.Blob
 		commitments []kzg4844.Commitment
 		proofs      []kzg4844.Proof
+		blobVersion byte
 	)
 	if tx.BlobTxSidecar() != nil {
 		blobs = tx.BlobTxSidecar().Blobs
 		commitments = tx.BlobTxSidecar().Commitments
 		proofs = tx.BlobTxSidecar().Proofs
+		blobVersion = tx.BlobTxSidecar().Version
 	}
 	return &apitypes.SendTxArgs{
 		From:                 common.NewMixedcaseAddress(addr),
@@ -278,6 +280,7 @@ func TxToSignTxArgs(addr common.Address, tx *types.Transaction) (*apitypes.SendT
 		ChainID:              (*hexutil.Big)(tx.ChainId()),
 		BlobFeeCap:           (*hexutil.Big)(tx.BlobGasFeeCap()),
 		BlobHashes:           tx.BlobHashes(),
+		BlobVersion:          blobVersion,
 		Blobs:                blobs,
 		Commitments:          commitments,
 		Proofs:               proofs,

arbnode/inbox_reader.go

@@ -665,7 +665,7 @@ func (r *InboxReader) getNextBlockToRead(ctx context.Context) (*big.Int, error)
 	if delayedCount == 0 {
 		return new(big.Int).Set(r.firstMessageBlock), nil
 	}
-	_, _, parentChainBlockNumber, err := r.tracker.GetDelayedMessageAccumulatorAndParentChainBlockNumber(ctx, delayedCount-1)
+	parentChainBlockNumber, err := r.tracker.GetParentChainBlockNumberFor(ctx, delayedCount-1)
 	if err != nil {
 		return nil, err
 	}

arbnode/inbox_tracker.go

@@ -347,6 +347,25 @@ func (t *InboxTracker) legacyGetDelayedMessageAndAccumulator(ctx context.Context
 }
 
 func (t *InboxTracker) GetDelayedMessageAccumulatorAndParentChainBlockNumber(ctx context.Context, seqNum uint64) (*arbostypes.L1IncomingMessage, common.Hash, uint64, error) {
+	msg, acc, blockNum, err := t.getRawDelayedMessageAccumulatorAndParentChainBlockNumber(ctx, seqNum)
+	if err != nil {
+		return msg, acc, blockNum, err
+	}
+	err = msg.FillInBatchGasFields(func(batchNum uint64) ([]byte, error) {
+		data, _, err := t.txStreamer.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+		return data, err
+	})
+	return msg, acc, blockNum, err
+}
+
+// does not return message, so does not need to fill in batchGasFields
+func (t *InboxTracker) GetParentChainBlockNumberFor(ctx context.Context, seqNum uint64) (uint64, error) {
+	_, _, blockNum, err := t.getRawDelayedMessageAccumulatorAndParentChainBlockNumber(ctx, seqNum)
+	return blockNum, err
+}
+
+// this function will not error
+func (t *InboxTracker) getRawDelayedMessageAccumulatorAndParentChainBlockNumber(ctx context.Context, seqNum uint64) (*arbostypes.L1IncomingMessage, common.Hash, uint64, error) {
 	delayedMessageKey := dbKey(rlpDelayedMessagePrefix, seqNum)
 	exists, err := t.db.Has(delayedMessageKey)
 	if err != nil {
@@ -371,14 +390,6 @@ func (t *InboxTracker) GetDelayedMessageAccumulatorAndParentChainBlockNumber(ctx
 		return msg, acc, 0, err
 	}
 
-	err = msg.FillInBatchGasFields(func(batchNum uint64) ([]byte, error) {
-		data, _, err := t.txStreamer.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
-		return data, err
-	})
-	if err != nil {
-		return msg, acc, 0, err
-	}
-
 	parentChainBlockNumberKey := dbKey(parentChainBlockNumberPrefix, seqNum)
 	exists, err = t.db.Has(parentChainBlockNumberKey)
 	if err != nil {

bold/chain-abstraction/sol-implementation/assertion_chain.go

@@ -661,7 +661,7 @@ func (a *AssertionChain) createAndStakeOnAssertion(
 	})
 	opts := a.GetCallOptsWithDesiredRpcHeadBlockNumber(&bind.CallOpts{Context: ctx})
 	if createErr := handleCreateAssertionError(err, postState.GlobalState.BlockHash); createErr != nil {
-		if strings.Contains(err.Error(), "already exists") {
+		if strings.Contains(createErr.Error(), "already exists") {
 			assertionItem, err2 := a.GetAssertion(ctx, opts, protocol.AssertionHash{Hash: computedHash})
 			if err2 != nil {
 				return nil, err2

broadcastclient/broadcastclient.go

@@ -196,7 +196,10 @@ func (bc *BroadcastClient) Start(ctxIn context.Context) {
 				errors.Is(err, ErrIncorrectChainId) ||
 				errors.Is(err, ErrMissingFeedServerVersion) ||
 				errors.Is(err, ErrIncorrectFeedServerVersion) {
-				bc.fatalErrChan <- fmt.Errorf("failed connecting to server feed due to %w", err)
+				select {
+				case bc.fatalErrChan <- fmt.Errorf("failed connecting to server feed due to %w", err):
+				case <-ctx.Done():
+				}
 				return
 			}
 			if err == nil {
@@ -486,7 +489,11 @@ func (bc *BroadcastClient) startBackgroundReader(earlyFrameData io.Reader) {
 						}
 					}
 					if res.ConfirmedSequenceNumberMessage != nil && bc.confirmedSequenceNumberListener != nil {
-						bc.confirmedSequenceNumberListener <- res.ConfirmedSequenceNumberMessage.SequenceNumber
+						select {
+						case bc.confirmedSequenceNumberListener <- res.ConfirmedSequenceNumberMessage.SequenceNumber:
+						case <-ctx.Done():
+							return
+						}
 					}
 				}
 			}

cmd/chaininfo/arbitrum_chain_info.json

@@ -218,7 +218,7 @@
     "chain-name": "sepolia-rollup",
     "sequencer-url": "https://sepolia-rollup-sequencer.arbitrum.io/rpc",
     "feed-url": "wss://sepolia-rollup.arbitrum.io/feed",
-    "feed-signed": true,
+    "feed-signed": false,
     "block-metadata-url": "https://sepolia-rollup.arbitrum.io/rpc",
     "track-block-metadata-from": 123000000,
     "chain-config": {

go-ethereum

@@ -478,16 +478,38 @@ func (s *Staker) tryFastConfirmationNodeNumber(ctx context.Context, number uint6
 	return s.tryFastConfirmation(ctx, nodeInfo.AfterState().GlobalState.BlockHash, nodeInfo.AfterState().GlobalState.SendRoot, hash)
 }
 
+func (s *Staker) flushTransactions(ctx context.Context) error {
+	arbTx, err := s.builder.ExecuteTransactions(ctx)
+	if err != nil {
+		return err
+	}
+	if arbTx != nil {
+		_, err = s.l1Reader.WaitForTxApproval(ctx, arbTx)
+		if err == nil {
+			log.Info("successfully executed staker transaction", "hash", arbTx.Hash())
+		} else {
+			return fmt.Errorf("error waiting for tx receipt: %w", err)
+		}
+	}
+	return nil
+}
+
 func (s *Staker) tryFastConfirmation(ctx context.Context, blockHash common.Hash, sendRoot common.Hash, nodeHash common.Hash) error {
 	if !s.config().EnableFastConfirmation {
 		return nil
 	}
+	// Make sure all previous transactions are flushed before trying to fast confirm
+	// to ensure that the newly created node is known on-chain before fast confirming it.
+	err := s.flushTransactions(ctx)
+	if err != nil {
+		return err
+	}
 	if s.fastConfirmSafe != nil {
 		return s.fastConfirmSafe.tryFastConfirmation(ctx, blockHash, sendRoot, nodeHash)
 	}
 	auth := s.builder.Auth(ctx)
 	log.Info("Fast confirming node with wallet", "wallet", auth.From, "nodeHash", nodeHash)
-	_, err := s.rollup.FastConfirmNextNode(auth, blockHash, sendRoot, nodeHash)
+	_, err = s.rollup.FastConfirmNextNode(auth, blockHash, sendRoot, nodeHash)
 	return err
 }