Sequencer Design

    TransactionPool {
        pending: Map<address, Transaction[]>,
        queued: Map<address, Transaction[]>,
        
        add(tx: Transaction) {
            // Validate transaction
            if (!this.validate(tx)) {
                throw new Error('Invalid transaction');
            }
            
            // Check nonce ordering
            if (tx.nonce === expectedNonce) {
                this.pending.add(tx);
            } else {
                this.queued.add(tx);
            }
        },
        
        getNextTransactions(limit: number) {
            // Return transactions ready for inclusion
            return this.pending.slice(0, limit);
        }
    }

    class BlockProducer {
        async produceBlock() {
            // Get pending transactions
            const txs = this.pool.getNextTransactions(10000);
            
            // Execute transactions
            const results = await this.executor.executeBatch(txs);
            
            // Create block
            const block = {
                number: this.currentBlockNumber++,
                timestamp: Date.now(),
                transactions: txs,
                receipts: results.receipts,
                stateRoot: results.stateRoot,
                gasUsed: results.totalGas
            };
            
            // Store block
            await this.db.saveBlock(block);
            
            // Emit to subscribers
            this.emit('newBlock', block);
            
            return block;
        }
    }

    class BatchPublisher {
        async publishBatch() {
            // Collect blocks since last batch
            const blocks = await this.getUnpublishedBlocks();
            
            // Compress transaction data
            const batchData = this.compress(blocks);
            
            // Compute state root
            const stateRoot = blocks[blocks.length - 1].stateRoot;
            
            // Post to L1
            const tx = await this.l1Contract.submitBatch(
                batchData,
                this.prevStateRoot,
                stateRoot
            );
            
            await tx.wait();
            
            console.log(`Batch published: ${blocks.length} blocks`);
        }
    }

    function selectTransactions(mempool) {
        // Sort by gas price (highest first)
        const sorted = mempool.pending.sort(
            (a, b) => b.gasPrice - a.gasPrice
        );
        
        // Fill block with highest paying TXs
        let gasUsed = 0;
        const selected = [];
        
        for (const tx of sorted) {
            if (gasUsed + tx.gasLimit > BLOCK_GAS_LIMIT) break;
            selected.push(tx);
            gasUsed += tx.gasLimit;
        }
        
        return selected;
    }

    function selectTransactions(mempool) {
        // Order by timestamp (encrypted until inclusion)
        const sorted = mempool.pending.sort(
            (a, b) => a.timestamp - b.timestamp
        );
        
        return sorted.slice(0, BLOCK_SIZE_LIMIT);
    }

    // L1 contract
    function forceInclude(
        address to,
        uint256 value,
        bytes calldata data
    ) external payable {
        // User submits TX directly to L1
        ForcedTransaction memory ftx = ForcedTransaction({
            from: msg.sender,
            to: to,
            value: value,
            data: data,
            timestamp: block.timestamp
        });
        
        forcedTransactions.push(ftx);
        
        emit TransactionForced(ftx);
    }