Merge pull request #209 from proto-kit/feature/configurable_block_size

Make Block Size Configurable

Author: rpanic

packages/sequencer/src/mempool/Mempool.ts

@@ -17,5 +17,5 @@ export interface Mempool<Events extends MempoolEvents = MempoolEvents>
   /**
    * Retrieve all transactions that are currently in the mempool
    */
-  getTxs: () => Promise<PendingTransaction[]>;
+  getTxs: (limit?: number) => Promise<PendingTransaction[]>;
 }

packages/sequencer/src/mempool/private/PrivateMempool.ts

@@ -93,7 +93,7 @@ export class PrivateMempool extends SequencerModule implements Mempool {
     return result?.result.afterNetworkState;
   }
 
-  public async getTxs(): Promise<PendingTransaction[]> {
+  public async getTxs(limit?: number): Promise<PendingTransaction[]> {
     const txs = await this.transactionStorage.getPendingUserTransactions();
     const executionContext = container.resolve<RuntimeMethodExecutionContext>(
       RuntimeMethodExecutionContext
@@ -108,7 +108,8 @@ export class PrivateMempool extends SequencerModule implements Mempool {
       baseCachedStateService,
       this.protocol.stateServiceProvider,
       networkState,
-      executionContext
+      executionContext,
+      limit
     );
     this.protocol.stateServiceProvider.popCurrentStateService();
     return sortedTxs;
@@ -128,13 +129,17 @@ export class PrivateMempool extends SequencerModule implements Mempool {
     baseService: CachedStateService,
     stateServiceProvider: StateServiceProvider,
     networkState: NetworkState,
-    executionContext: RuntimeMethodExecutionContext
+    executionContext: RuntimeMethodExecutionContext,
+    limit?: number
   ): Promise<PendingTransaction[]> {
     const skippedTransactions: Record<string, MempoolTransactionPaths> = {};
     const sortedTransactions: PendingTransaction[] = [];
     let queue: PendingTransaction[] = [...transactions];
 
-    while (queue.length > 0) {
+    while (
+      queue.length > 0 &&
+      (limit !== undefined ? sortedTransactions.length < limit : true)
+    ) {
       const [tx] = queue.splice(0, 1);
       const txStateService = new CachedStateService(baseService);
       stateServiceProvider.setCurrentStateService(txStateService);

packages/sequencer/src/protocol/production/sequencing/BlockProducerModule.ts

@@ -26,6 +26,7 @@ import { TransactionExecutionService } from "./TransactionExecutionService";
 
 export interface BlockConfig {
   allowEmptyBlock?: boolean;
+  maximumBlockSize?: number;
 }
 
 @sequencerModule()
@@ -55,6 +56,10 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
     return this.config.allowEmptyBlock ?? true;
   }
 
+  private maximumBlockSize() {
+    return this.config.maximumBlockSize ?? 20;
+  }
+
   private prettyPrintBlockContents(block: Block) {
     block.transactions.forEach((tx, i) => {
       const methodName = this.methodIdResolver.getMethodNameFromId(
@@ -144,7 +149,7 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
     txs: PendingTransaction[];
     metadata: BlockWithResult;
   }> {
-    const txs = await this.mempool.getTxs();
+    const txs = await this.mempool.getTxs(this.maximumBlockSize());
 
     const parentBlock = await this.blockQueue.getLatestBlock();
 

packages/sequencer/test/integration/BlockProductionSize.test.ts

@@ -0,0 +1,141 @@
+import { log } from "@proto-kit/common";
+import { VanillaProtocolModules } from "@proto-kit/library";
+import { Runtime } from "@proto-kit/module";
+import { Protocol } from "@proto-kit/protocol";
+import { AppChain } from "@proto-kit/sdk";
+import { Bool, PrivateKey, Struct, UInt64 } from "o1js";
+import "reflect-metadata";
+import { container } from "tsyringe";
+
+import { ManualBlockTrigger, PrivateMempool, Sequencer } from "../../src";
+import {
+  DefaultTestingSequencerModules,
+  testingSequencerFromModules,
+} from "../TestingSequencer";
+
+import { Balance } from "./mocks/Balance";
+import { ProtocolStateTestHook } from "./mocks/ProtocolStateTestHook";
+import { createTransaction } from "./utils";
+import { NoopRuntime } from "./mocks/NoopRuntime";
+
+export class PrimaryTestEvent extends Struct({
+  message: Bool,
+}) {}
+
+export class SecondaryTestEvent extends Struct({
+  message: Bool,
+}) {}
+
+describe("block limit", () => {
+  let runtime: Runtime<{
+    Balance: typeof Balance;
+    NoopRuntime: typeof NoopRuntime;
+  }>;
+  let sequencer: Sequencer<DefaultTestingSequencerModules>;
+
+  let blockTrigger: ManualBlockTrigger;
+  let mempool: PrivateMempool;
+
+  log.setLevel(log.levels.INFO);
+
+  const runtimeClass = Runtime.from({
+    modules: {
+      Balance,
+      NoopRuntime,
+    },
+
+    config: {
+      Balance: {},
+      NoopRuntime: {},
+    },
+  });
+
+  async function setUpAppChain(maxBlockSize: number | undefined) {
+    const sequencerClass = testingSequencerFromModules({});
+
+    const protocolClass = Protocol.from({
+      modules: VanillaProtocolModules.mandatoryModules({
+        ProtocolStateTestHook,
+      }),
+    });
+
+    const app = AppChain.from({
+      Runtime: runtimeClass,
+      Sequencer: sequencerClass,
+      Protocol: protocolClass,
+      modules: {},
+    });
+    log.setLevel("TRACE");
+
+    app.configure({
+      Sequencer: {
+        Database: {},
+        BlockTrigger: {},
+        Mempool: {},
+        BatchProducerModule: {},
+        BlockProducerModule: {
+          maximumBlockSize: maxBlockSize,
+        },
+        LocalTaskWorkerModule: {},
+        BaseLayer: {},
+        TaskQueue: {},
+        FeeStrategy: {},
+        ProtocolStartupModule: {},
+      },
+      Runtime: {
+        Balance: {},
+        NoopRuntime: {},
+      },
+      Protocol: {
+        AccountState: {},
+        BlockProver: {},
+        StateTransitionProver: {},
+        BlockHeight: {},
+        LastStateRoot: {},
+        ProtocolStateTestHook: {},
+      },
+    });
+
+    // Start AppChain
+    await app.start(container.createChildContainer());
+
+    ({ runtime, sequencer } = app);
+
+    mempool = sequencer.resolve("Mempool");
+
+    const privateKey = PrivateKey.random();
+
+    for (let i = 0; i < 40; i++) {
+      const tx = createTransaction({
+        runtime,
+        method: ["Balance", "setBalanceIf"],
+        privateKey: privateKey,
+        args: [privateKey.toPublicKey(), UInt64.from(100), Bool(true)],
+        nonce: i,
+      });
+      await mempool.add(tx);
+    }
+  }
+
+  it.each([
+    [5, 5],
+    [10, 10],
+    [15, 15],
+    [25, 25],
+    [35, 35],
+    [undefined, 20],
+  ])(
+    "when limit is set to %p should produce block with maximum size %p",
+    async (limit, maxValue) => {
+      await setUpAppChain(limit);
+
+      blockTrigger = sequencer.resolve("BlockTrigger");
+
+      const block = await blockTrigger.produceBlock();
+
+      expect(block).toBeDefined();
+      expect(block!.transactions).toHaveLength(maxValue);
+    },
+    30000
+  );
+});