Implement Facet V2 batch system with EIP-4844 blob support

[RogerPodacter]

Summary

This PR implements the Facet V2 batching protocol, enabling significant cost reductions through transaction batching and EIP-4844 blob support. This is the first rollup protocol to support both permissionless batching and priority sequencing simultaneously.

What's Implemented

Core Features

• Batch submission via multiple transports: Calldata and EIP-4844 blobs (events only support V1 single transactions)
• RLP encoding for all batch data structures
• Dual-role system: Priority batches (authorized sequencer) and forced batches (permissionless)
• Gas validation for priority batches to ensure they don't exceed their 80% allocation
• EIP-4844 blob support through beacon node integration
• Content-based deduplication of identical batches
• Full backwards compatibility with V1 single transaction format

Key Components

• FacetBatchCollector: Scans L1 blocks for transactions from all sources (V1 singles, V2 batches)
• FacetBatchParser: Parses and validates RLP-encoded batch format
• FacetBlockBuilder: Implements transaction ordering rules (priority first, then permissionless)
• StandardL2Transaction: Handles standard EIP-2718 typed transactions (EIP-1559, EIP-2930, legacy)
• BlobProvider: Fetches EIP-4844 blobs from beacon nodes
• BatchSignatureVerifier: Placeholder for EIP-712 signature verification (not yet implemented)

Configuration

• FACET_BATCH_V2_ENABLED: Feature flag to enable V2 protocol
• PRIORITY_SHARE_BPS: Priority sequencer gas allocation (default 8000 = 80%)
• MAX_BATCH_BYTES: Maximum batch size (128KB default)
• MAX_TXS_PER_BATCH: Maximum transactions per batch (1000)

Testing

Comprehensive test coverage including:

• End-to-end blob integration tests
• Mixed V1/V2 transaction ordering scenarios
• Gas validation and priority batch rejection
• Batch parsing and deduplication
• Malformed data handling
• Multi-batch blob support

Migration

Fully backwards compatible - existing V1 transactions continue working unchanged. Enable with FACET_BATCH_V2_ENABLED=true.

---

Note

Implements Facet V2 batching (calldata + blob) with parsing/ordering, beacon-node blob integration, a new TypeScript micro‑sequencer, CI/Dockerization, and extensive tests/refactors across importer, minting, and infra.

• Protocol/Backend:
  • Facet V2 Batching: Add FacetBatchCollector, FacetBatchParser, FacetBlockBuilder, FacetBatchConstants, ParsedBatch, StandardL2Transaction, and BatchSignatureVerifier with priority/permissionless roles, gas checks, and content-hash dedupe.
  • Blob Support (EIP-4844): Add BlobProvider, EthereumBeaconNodeClient, and BlobUtils for blob fetching/encoding; integrate blob batch collection.
  • Importer/Infra: Enhance L1RpcPrefetcher and EthBlockImporter (prefetch flow, error handling, shutdown), add ImportProfiler, and improve GethDriver logging/flow.
  • Minting: Update FctMintCalculator, FctMintCalculatorAlbatross, and MintPeriod to ignore standard L2 txs for mint and handle fork-period logic.
  • Config: Add PriorityRegistry; expand env/network handling (e.g., hoodi); minor sysconfig/chain updates.
• Sequencer (Node/TS):
  • Add lightweight micro‑sequencer (src/ services for batching, posting via direct/DA Builder, monitoring, API), scripts, and Dockerfile.
• CI/DevOps:
  • Add GitHub Actions to build/publish images (build-images.yml, build-sequencer.yml).
  • Update docker-compose to include sequencer service; add env examples.
• Tests/Docs:
  • Add comprehensive specs for blobs, batch parsing/ordering, reorg handling, minting; add test pages & utilities.
• Misc:
  • Minor project hygiene (ignore files, gems, logging).

^{Written by Cursor Bugbot for commit 271e854. This will update automatically on new commits. Configure here.}

[Copilot]

Pull Request Overview

This PR implements the Facet V2 batching protocol, introducing a new transaction batching system that significantly reduces costs through EIP-4844 blob support and permissionless batching. The implementation enables dual-role sequencing with both priority batches (authorized sequencer) and forced batches (permissionless) while maintaining full backwards compatibility with V1 single transactions.

Key changes include:

• Multi-transport batch support: Calldata and EIP-4844 blobs with RLP encoding
• Transaction ordering system: Priority batches processed first, then forced batches by L1 index
• Blob integration infrastructure: Beacon node client, blob utils, and provider components
• Gas validation and deduplication: Priority batch limits and content-based batch deduplication

Reviewed Changes

Copilot reviewed 29 out of 29 changed files in this pull request and generated 6 comments.

Show a summary per file

File	Description
spec/support/facet_transaction_helper.rb	Enhanced test helper to support V2 batch transactions alongside V1 singles
spec/support/blob_test_helper.rb	New comprehensive blob testing utilities for EIP-4844 integration
spec/services/*.rb	Test coverage for all batch processing components (collector, parser, builder)
spec/integration/*.rb	End-to-end integration tests for blob processing and mixed transaction scenarios
lib/sys_config.rb	Configuration for V2 protocol features and priority sequencer settings
lib/blob_utils.rb	EIP-4844 blob encoding/decoding utilities with proper field element handling
app/services/facet_batch_*.rb	Core batch processing pipeline (collector, parser, builder)
app/services/blob_provider.rb	Beacon node integration for blob fetching
app/models/*.rb	Data structures for parsed batches, constants, and standard L2 transactions

---

_{Tip: Customize your code reviews with copilot-instructions.md. Create the file or learn how to get started.}

[Copilot]

[nitpick] The comment accurately explains the limitation but could be improved. Consider documenting the specific use case where this distinction matters and provide guidance on how to query batch transactions from L2 blocks.

[Copilot]

[nitpick] Using allow_any_instance_of can lead to brittle tests. Consider injecting the gas calculator as a dependency or using a more targeted stub approach to improve test maintainability.

Suggested change

	before do
	# Mock gas calculation to exceed limit for priority batch only
	allow_any_instance_of(described_class).to receive(:calculate_batch_gas) do |instance, batch|
	if batch.is_priority?
	l2_block_gas_limit + 1 # Over limit
	else
	100 # Under limit
	end
	end
	end
	let(:batch_gas_calculator) do
	->(batch) {
	if batch.is_priority?
	l2_block_gas_limit + 1 # Over limit
	else
	100 # Under limit
	end
	}
	end
	let(:builder) do
	described_class.new(
	collected: collected,
	l2_block_gas_limit: l2_block_gas_limit,
	get_authorized_signer: ->(block) { authorized_signer },
	batch_gas_calculator: batch_gas_calculator
	)
	end

[Copilot]

The remaining.include?(0x80) operation scans the entire remaining array for each byte, creating O(n²) complexity. Consider using a more efficient approach like tracking if a terminator has been found or scanning once to find the terminator position.

Suggested change

	while active && pos < bytes.length
	# Skip leading 0x00 of the field element
	pos += 1
	consume = [BYTES_PER_FIELD_ELEMENT - 1, bytes.length - pos].min
	consume.times do
	byte = bytes[pos]
	pos += 1
	remaining = bytes[pos..-1] || []
	# Match viem: terminator if this byte is 0x80 and there is no other 0x80 in the rest of the current blob
	is_terminator = (byte == 0x80) && !remaining.include?(0x80)
	if is_terminator
	active = false
	break
	end
	out << byte
	end
	end
	# Find the position of the first 0x80 (terminator) in the blob
	terminator_index = bytes.index(0x80)
	# If no terminator, process the whole blob; else, process up to the terminator
	process_up_to = terminator_index ? terminator_index : bytes.length
	while active && pos < process_up_to
	# Skip leading 0x00 of the field element
	pos += 1
	consume = [BYTES_PER_FIELD_ELEMENT - 1, process_up_to - pos].min
	consume.times do
	break if pos >= process_up_to
	byte = bytes[pos]
	pos += 1
	out << byte
	end
	end
	# If a terminator was found, stop processing further blobs
	if terminator_index
	active = false
	end

[Copilot]

The signature verification is not implemented, which is a security concern for priority batches. Consider either implementing the verification or adding stronger documentation about this limitation and its security implications.

[Copilot]

[nitpick] Consider extracting the transaction collection logic into a strategy pattern or separate service class to reduce complexity in the importer and improve testability of the V2 collection logic.

[Copilot]

Returning a zero address on signature recovery failure could mask serious issues. Consider either raising an exception or returning a more specific error indication that doesn't look like a valid address.