@aztec/sequencer-client 0.0.1-commit.d3ec352c → 0.0.1-commit.e3c1de76

package/src/test/mock_checkpoint_builder.ts

@@ -0,0 +1,309 @@
+import { type BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { L2Block } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { Gas } from '@aztec/stdlib/gas';
+import type {
+  FullNodeBlockBuilderConfig,
+  ICheckpointBlockBuilder,
+  ICheckpointsBuilder,
+  MerkleTreeWriteOperations,
+  PublicProcessorLimits,
+} from '@aztec/stdlib/interfaces/server';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
+import type { CheckpointGlobalVariables, Tx } from '@aztec/stdlib/tx';
+import type { BuildBlockInCheckpointResult } from '@aztec/validator-client';
+
+/**
+ * A fake CheckpointBuilder for testing that implements the same interface as the real one.
+ * Can be seeded with blocks to return sequentially on each `buildBlock` call.
+ */
+export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
+  private blocks: L2Block[] = [];
+  private builtBlocks: L2Block[] = [];
+  private usedTxsPerBlock: Tx[][] = [];
+  private blockIndex = 0;
+
+  /** Optional function to dynamically provide the block (alternative to seedBlocks) */
+  private blockProvider: (() => L2Block) | undefined = undefined;
+
+  /** Track calls for assertions */
+  public buildBlockCalls: Array<{
+    blockNumber: BlockNumber;
+    timestamp: bigint;
+    opts: PublicProcessorLimits;
+  }> = [];
+  /** Track all consumed transaction hashes across buildBlock calls */
+  public consumedTxHashes: Set<string> = new Set();
+  public completeCheckpointCalled = false;
+  public getCheckpointCalled = false;
+
+  /** Set to an error to make buildBlock throw on next call */
+  public errorOnBuild: Error | undefined = undefined;
+
+  constructor(
+    private readonly constants: CheckpointGlobalVariables,
+    private readonly checkpointNumber: CheckpointNumber,
+  ) {}
+
+  /** Seed the builder with blocks to return on successive buildBlock calls */
+  seedBlocks(blocks: L2Block[], usedTxsPerBlock?: Tx[][]): this {
+    this.blocks = blocks;
+    this.usedTxsPerBlock = usedTxsPerBlock ?? blocks.map(() => []);
+    this.blockIndex = 0;
+    this.blockProvider = undefined;
+    return this;
+  }
+
+  /**
+   * Set a function that provides blocks dynamically.
+   * Useful for tests where the block is determined at call time (e.g., sequencer tests).
+   */
+  setBlockProvider(provider: () => L2Block): this {
+    this.blockProvider = provider;
+    this.blocks = [];
+    return this;
+  }
+
+  getConstantData(): CheckpointGlobalVariables {
+    return this.constants;
+  }
+
+  async buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    timestamp: bigint,
+    opts: PublicProcessorLimits,
+  ): Promise<BuildBlockInCheckpointResult> {
+    this.buildBlockCalls.push({ blockNumber, timestamp, opts });
+
+    if (this.errorOnBuild) {
+      throw this.errorOnBuild;
+    }
+
+    let block: L2Block;
+    let usedTxs: Tx[];
+
+    if (this.blockProvider) {
+      // Dynamic mode: get block from provider
+      block = this.blockProvider();
+      usedTxs = [];
+      this.builtBlocks.push(block);
+    } else {
+      // Seeded mode: get block from pre-seeded list
+      block = this.blocks[this.blockIndex];
+      usedTxs = this.usedTxsPerBlock[this.blockIndex] ?? [];
+      this.blockIndex++;
+      this.builtBlocks.push(block);
+    }
+
+    // Check that no pending tx has already been consumed
+    for await (const tx of pendingTxs) {
+      const hash = tx.getTxHash().toString();
+      if (this.consumedTxHashes.has(hash)) {
+        throw new Error(`Transaction ${hash} was already consumed in a previous block`);
+      }
+    }
+
+    // Add used txs to consumed set
+    for (const tx of usedTxs) {
+      this.consumedTxHashes.add(tx.getTxHash().toString());
+    }
+
+    return {
+      block,
+      publicGas: Gas.empty(),
+      publicProcessorDuration: 0,
+      numTxs: block?.body?.txEffects?.length ?? usedTxs.length,
+      usedTxs,
+      failedTxs: [],
+      usedTxBlobFields: block?.body?.txEffects?.reduce((sum, tx) => sum + tx.getNumBlobFields(), 0) ?? 0,
+    };
+  }
+
+  completeCheckpoint(): Promise<Checkpoint> {
+    this.completeCheckpointCalled = true;
+    const allBlocks = this.blockProvider ? this.builtBlocks : this.blocks;
+    const lastBlock = allBlocks[allBlocks.length - 1];
+    // Create a CheckpointHeader from the last block's header for testing
+    const checkpointHeader = this.createCheckpointHeader(lastBlock);
+    return Promise.resolve(
+      new Checkpoint(
+        makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
+        checkpointHeader,
+        allBlocks,
+        this.checkpointNumber,
+      ),
+    );
+  }
+
+  getCheckpoint(): Promise<Checkpoint> {
+    this.getCheckpointCalled = true;
+    const builtBlocks = this.blockProvider ? this.builtBlocks : this.blocks.slice(0, this.blockIndex);
+    const lastBlock = builtBlocks[builtBlocks.length - 1];
+    if (!lastBlock) {
+      throw new Error('No blocks built yet');
+    }
+    // Create a CheckpointHeader from the last block's header for testing
+    const checkpointHeader = this.createCheckpointHeader(lastBlock);
+    return Promise.resolve(
+      new Checkpoint(
+        makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
+        checkpointHeader,
+        builtBlocks,
+        this.checkpointNumber,
+      ),
+    );
+  }
+
+  /**
+   * Creates a CheckpointHeader from a block's header for testing.
+   * This is a simplified version that creates a minimal CheckpointHeader.
+   */
+  private createCheckpointHeader(block: L2Block): CheckpointHeader {
+    const header = block.header;
+    const gv = header.globalVariables;
+    return CheckpointHeader.empty({
+      lastArchiveRoot: header.lastArchive.root,
+      blockHeadersHash: Fr.random(), // Use random for testing
+      slotNumber: gv.slotNumber,
+      timestamp: gv.timestamp,
+      coinbase: gv.coinbase,
+      feeRecipient: gv.feeRecipient,
+      gasFees: gv.gasFees,
+      totalManaUsed: header.totalManaUsed,
+    });
+  }
+
+  /** Reset for reuse in another test */
+  reset(): void {
+    this.blocks = [];
+    this.builtBlocks = [];
+    this.usedTxsPerBlock = [];
+    this.blockIndex = 0;
+    this.buildBlockCalls = [];
+    this.consumedTxHashes.clear();
+    this.completeCheckpointCalled = false;
+    this.getCheckpointCalled = false;
+    this.errorOnBuild = undefined;
+    this.blockProvider = undefined;
+  }
+}
+
+/**
+ * A fake CheckpointsBuilder (factory) for testing that implements the same interface
+ * as FullNodeCheckpointsBuilder. Returns MockCheckpointBuilder instances.
+ * Does NOT use jest mocks - this is a proper test double.
+ */
+export class MockCheckpointsBuilder implements ICheckpointsBuilder {
+  private checkpointBuilder: MockCheckpointBuilder | undefined;
+
+  /** Track calls for assertions */
+  public startCheckpointCalls: Array<{
+    checkpointNumber: CheckpointNumber;
+    constants: CheckpointGlobalVariables;
+    l1ToL2Messages: Fr[];
+    previousCheckpointOutHashes: Fr[];
+  }> = [];
+  public openCheckpointCalls: Array<{
+    checkpointNumber: CheckpointNumber;
+    constants: CheckpointGlobalVariables;
+    l1ToL2Messages: Fr[];
+    previousCheckpointOutHashes: Fr[];
+    existingBlocks: L2Block[];
+  }> = [];
+  public updateConfigCalls: Array<Partial<FullNodeBlockBuilderConfig>> = [];
+
+  /**
+   * Set the MockCheckpointBuilder to return from startCheckpoint.
+   * Must be called before startCheckpoint is invoked.
+   */
+  setCheckpointBuilder(builder: MockCheckpointBuilder): this {
+    this.checkpointBuilder = builder;
+    return this;
+  }
+
+  /**
+   * Creates a new MockCheckpointBuilder with the given constants.
+   * Convenience method that creates and sets the builder in one call.
+   */
+  createCheckpointBuilder(
+    constants: CheckpointGlobalVariables,
+    checkpointNumber: CheckpointNumber,
+  ): MockCheckpointBuilder {
+    this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+    return this.checkpointBuilder;
+  }
+
+  /** Get the current checkpoint builder (for assertions) */
+  getCheckpointBuilder(): MockCheckpointBuilder | undefined {
+    return this.checkpointBuilder;
+  }
+
+  getConfig(): FullNodeBlockBuilderConfig {
+    return {
+      l1GenesisTime: 0n,
+      slotDuration: 24,
+      l1ChainId: 1,
+      rollupVersion: 1,
+    };
+  }
+
+  updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void {
+    this.updateConfigCalls.push(config);
+  }
+
+  startCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
+    _fork: MerkleTreeWriteOperations,
+  ): Promise<ICheckpointBlockBuilder> {
+    this.startCheckpointCalls.push({ checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes });
+
+    if (!this.checkpointBuilder) {
+      // Auto-create a builder if none was set
+      this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+    }
+
+    return Promise.resolve(this.checkpointBuilder);
+  }
+
+  openCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
+    _fork: MerkleTreeWriteOperations,
+    existingBlocks: L2Block[] = [],
+  ): Promise<ICheckpointBlockBuilder> {
+    this.openCheckpointCalls.push({
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      existingBlocks,
+    });
+
+    if (!this.checkpointBuilder) {
+      // Auto-create a builder if none was set
+      this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+    }
+
+    return Promise.resolve(this.checkpointBuilder);
+  }
+
+  getFork(_blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations> {
+    throw new Error('MockCheckpointsBuilder.getFork not implemented');
+  }
+
+  /** Reset for reuse in another test */
+  reset(): void {
+    this.checkpointBuilder = undefined;
+    this.startCheckpointCalls = [];
+    this.openCheckpointCalls = [];
+    this.updateConfigCalls = [];
+  }
+}

package/src/test/utils.ts

@@ -0,0 +1,164 @@
+import { Body } from '@aztec/aztec.js/block';
+import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import { times } from '@aztec/foundation/collection';
+import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import type { P2P } from '@aztec/p2p';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { BlockProposal, CheckpointAttestation, CheckpointProposal, ConsensusPayload } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeAppendOnlyTreeSnapshot, mockTxForRollup } from '@aztec/stdlib/testing';
+import { BlockHeader, GlobalVariables, type Tx, makeProcessedTxFromPrivateOnlyTx } from '@aztec/stdlib/tx';
+
+import type { MockProxy } from 'jest-mock-extended';
+
+// Re-export mock classes from their dedicated file
+export { MockCheckpointBuilder, MockCheckpointsBuilder } from './mock_checkpoint_builder.js';
+
+/**
+ * Creates a mock transaction with a specific seed for deterministic testing
+ */
+export async function makeTx(seed?: number, chainId?: Fr): Promise<Tx> {
+  const tx = await mockTxForRollup(seed);
+  if (chainId) {
+    tx.data.constants.txContext.chainId = chainId;
+  }
+  return tx;
+}
+
+/**
+ * Creates an L2Block from transactions and global variables
+ */
+export async function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Promise<L2Block> {
+  const processedTxs = await Promise.all(
+    txs.map(tx =>
+      makeProcessedTxFromPrivateOnlyTx(tx, Fr.ZERO, new PublicDataWrite(Fr.random(), Fr.random()), globalVariables),
+    ),
+  );
+  const body = new Body(processedTxs.map(tx => tx.txEffect));
+  const header = BlockHeader.empty({ globalVariables });
+  const archive = makeAppendOnlyTreeSnapshot(globalVariables.blockNumber + 1);
+  return new L2Block(
+    archive,
+    header,
+    body,
+    CheckpointNumber.fromBlockNumber(globalVariables.blockNumber),
+    IndexWithinCheckpoint(0),
+  );
+}
+
+/**
+ * Mocks the P2P client to return specific pending transactions
+ */
+export function mockPendingTxs(p2p: MockProxy<P2P>, txs: Tx[]): void {
+  p2p.getPendingTxCount.mockResolvedValue(txs.length);
+  p2p.iteratePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
+}
+
+/**
+ * Creates an async iterator for transactions
+ */
+export async function* mockTxIterator(txs: Promise<Tx[]>): AsyncIterableIterator<Tx> {
+  for (const tx of await txs) {
+    yield tx;
+  }
+}
+
+/**
+ * Creates mock committee attestations from a signer
+ */
+export function createMockSignatures(signer: Secp256k1Signer): CommitteeAttestation[] {
+  const mockedSig = Signature.random();
+  return [new CommitteeAttestation(signer.address, mockedSig)];
+}
+
+/**
+ * Creates a CheckpointHeader from an L2Block for testing purposes.
+ * Uses mock values for blockHeadersHash, blobsHash and inHash since L2Block doesn't have these fields.
+ */
+function createCheckpointHeaderFromBlock(block: L2Block): CheckpointHeader {
+  const gv = block.header.globalVariables;
+  return new CheckpointHeader(
+    block.header.lastArchive.root,
+    Fr.random(), // blockHeadersHash - mock value for testing
+    Fr.random(), // blobsHash - mock value for testing
+    Fr.random(), // inHash - mock value for testing
+    Fr.random(), // outHash - mock value for testing
+    gv.slotNumber,
+    gv.timestamp,
+    gv.coinbase,
+    gv.feeRecipient,
+    gv.gasFees,
+    block.header.totalManaUsed,
+  );
+}
+
+/**
+ * Creates a block proposal from a block and signature
+ */
+export function createBlockProposal(block: L2Block, signature: Signature): BlockProposal {
+  const txHashes = block.body.txEffects.map(tx => tx.txHash);
+  return new BlockProposal(
+    block.header,
+    block.indexWithinCheckpoint,
+    Fr.ZERO, // inHash - using zero for testing
+    block.archive.root,
+    txHashes,
+    signature,
+  );
+}
+
+/**
+ * Creates a checkpoint proposal from a block and signature
+ */
+export function createCheckpointProposal(
+  block: L2Block,
+  checkpointSignature: Signature,
+  blockSignature?: Signature,
+): CheckpointProposal {
+  const txHashes = block.body.txEffects.map(tx => tx.txHash);
+  const checkpointHeader = createCheckpointHeaderFromBlock(block);
+  return new CheckpointProposal(checkpointHeader, block.archive.root, checkpointSignature, {
+    blockHeader: block.header,
+    indexWithinCheckpoint: block.indexWithinCheckpoint,
+    txHashes,
+    signature: blockSignature ?? checkpointSignature, // Use checkpoint signature as block signature if not provided
+  });
+}
+
+/**
+ * Creates a checkpoint attestation from a block and signature.
+ * Note: We manually set the sender since we use random signatures in tests.
+ * In production, the sender is recovered from the signature.
+ */
+export function createCheckpointAttestation(
+  block: L2Block,
+  signature: Signature,
+  sender: EthAddress,
+): CheckpointAttestation {
+  const checkpointHeader = createCheckpointHeaderFromBlock(block);
+  const payload = new ConsensusPayload(checkpointHeader, block.archive.root);
+  const attestation = new CheckpointAttestation(payload, signature, signature);
+  // Set sender directly for testing (bypasses signature recovery)
+  (attestation as any).sender = sender;
+  return attestation;
+}
+
+/**
+ * Creates transactions and a block, and mocks P2P to return them.
+ * Helper for tests that need to set up a block with transactions.
+ */
+export async function setupTxsAndBlock(
+  p2p: MockProxy<P2P>,
+  globalVariables: GlobalVariables,
+  txCount: number,
+  chainId: Fr,
+): Promise<{ txs: Tx[]; block: L2Block }> {
+  const txs = await Promise.all(times(txCount, i => makeTx(i + 1, chainId)));
+  const block = await makeBlock(txs, globalVariables);
+  mockPendingTxs(p2p, txs);
+  return { txs, block };
+}

package/dest/sequencer/block_builder.d.ts

@@ -1,28 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/fields';
-import { DateProvider } from '@aztec/foundation/timer';
-import { PublicProcessor } from '@aztec/simulator/server';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
-import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
-import type { BuildBlockResult, FullNodeBlockBuilderConfig, IFullNodeBlockBuilder, MerkleTreeWriteOperations, PublicProcessorLimits, PublicProcessorValidator, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { GlobalVariables, Tx } from '@aztec/stdlib/tx';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-export declare function buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, l1ToL2Messages: Fr[], newGlobalVariables: GlobalVariables, opts: PublicProcessorLimits | undefined, worldStateFork: MerkleTreeWriteOperations, processor: PublicProcessor, validator: PublicProcessorValidator, l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>, dateProvider: DateProvider, telemetryClient?: TelemetryClient): Promise<BuildBlockResult>;
-export declare class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
-    private config;
-    private worldState;
-    private contractDataSource;
-    private dateProvider;
-    private telemetryClient;
-    constructor(config: FullNodeBlockBuilderConfig, worldState: WorldStateSynchronizer, contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient?: TelemetryClient);
-    getConfig(): FullNodeBlockBuilderConfig;
-    updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void;
-    makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations): Promise<{
-        processor: PublicProcessor;
-        validator: PublicProcessorValidator;
-    }>;
-    private syncToPreviousBlock;
-    buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, l1ToL2Messages: Fr[], globalVariables: GlobalVariables, opts: PublicProcessorLimits, suppliedFork?: MerkleTreeWriteOperations): Promise<BuildBlockResult>;
-    getFork(blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations>;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/sequencer/block_builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block_builder.d.ts","sourceRoot":"","sources":["../../src/sequencer/block_builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAInD,OAAO,EAAE,YAAY,EAAkB,MAAM,yBAAyB,CAAC;AAGvE,OAAO,EAGL,eAAe,EAEhB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,6BAA6B,CAAC;AAE1F,OAAO,KAAK,EACV,gBAAgB,EAChB,0BAA0B,EAC1B,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAMnF,wBAAsB,UAAU,CAC9B,UAAU,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,EAC5C,cAAc,EAAE,EAAE,EAAE,EACpB,kBAAkB,EAAE,eAAe,EACnC,IAAI,mCAA4B,EAChC,cAAc,EAAE,yBAAyB,EACzC,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,wBAAwB,EACnC,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,CAAC,EACtE,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAsC,GACtD,OAAO,CAAC,gBAAgB,CAAC,CA4C3B;AAWD,qBAAa,oBAAqB,YAAW,qBAAqB;IAE9D,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,eAAe;IALzB,YACU,MAAM,EAAE,0BAA0B,EAClC,UAAU,EAAE,sBAAsB,EAClC,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAsC,EAC7D;IAEG,SAAS,IAAI,0BAA0B,CAE7C;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,0BAA0B,CAAC,QAE9D;IAEY,oBAAoB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,yBAAyB;;;OAyClG;YAEa,mBAAmB;IAU3B,UAAU,CACd,UAAU,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,EAC5C,cAAc,EAAE,EAAE,EAAE,EACpB,eAAe,EAAE,eAAe,EAChC,IAAI,EAAE,qBAAqB,EAC3B,YAAY,CAAC,EAAE,yBAAyB,GACvC,OAAO,CAAC,gBAAgB,CAAC,CAsC3B;IAED,OAAO,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAEpE;CACF"}

package/dest/sequencer/block_builder.js

@@ -1,134 +0,0 @@
-import { MerkleTreeId } from '@aztec/aztec.js/trees';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { merge, pick } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
-import { retryUntil } from '@aztec/foundation/retry';
-import { bufferToHex } from '@aztec/foundation/string';
-import { Timer, elapsed } from '@aztec/foundation/timer';
-import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
-import { LightweightBlockFactory } from '@aztec/prover-client/block-factory';
-import { GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor, TelemetryCppPublicTxSimulator } from '@aztec/simulator/server';
-import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
-import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
-import { Gas } from '@aztec/stdlib/gas';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import { createValidatorForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
-const log = createLogger('block-builder');
-export async function buildBlock(pendingTxs, l1ToL2Messages, newGlobalVariables, opts = {}, worldStateFork, processor, validator, l1Constants, dateProvider, telemetryClient = getTelemetryClient()) {
-    const blockBuildingTimer = new Timer();
-    const blockNumber = newGlobalVariables.blockNumber;
-    const slot = newGlobalVariables.slotNumber;
-    const msgCount = l1ToL2Messages.length;
-    const stateReference = await worldStateFork.getStateReference();
-    const archiveTree = await worldStateFork.getTreeInfo(MerkleTreeId.ARCHIVE);
-    log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
-        slot,
-        slotStart: new Date(Number(getTimestampForSlot(slot, l1Constants)) * 1000),
-        now: new Date(dateProvider.now()),
-        blockNumber,
-        msgCount,
-        initialStateReference: stateReference.toInspect(),
-        initialArchiveRoot: bufferToHex(archiveTree.root),
-        opts
-    });
-    const blockFactory = new LightweightBlockFactory(worldStateFork, telemetryClient);
-    await blockFactory.startNewBlock(newGlobalVariables, l1ToL2Messages);
-    const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(()=>processor.process(pendingTxs, opts, validator));
-    // All real transactions have been added, set the block as full and pad if needed
-    await blockFactory.addTxs(processedTxs);
-    const block = await blockFactory.setBlockCompleted();
-    // How much public gas was processed
-    const publicGas = processedTxs.reduce((acc, tx)=>acc.add(tx.gasUsed.publicGas), Gas.empty());
-    const res = {
-        block,
-        publicGas,
-        publicProcessorDuration,
-        numMsgs: l1ToL2Messages.length,
-        numTxs: processedTxs.length,
-        failedTxs: failedTxs,
-        blockBuildingTimer,
-        usedTxs
-    };
-    log.trace('Built block', res.block.header);
-    return res;
-}
-const FullNodeBlockBuilderConfigKeys = [
-    'l1GenesisTime',
-    'slotDuration',
-    'l1ChainId',
-    'rollupVersion',
-    'txPublicSetupAllowList',
-    'fakeProcessingDelayPerTxMs'
-];
-export class FullNodeBlockBuilder {
-    config;
-    worldState;
-    contractDataSource;
-    dateProvider;
-    telemetryClient;
-    constructor(config, worldState, contractDataSource, dateProvider, telemetryClient = getTelemetryClient()){
-        this.config = config;
-        this.worldState = worldState;
-        this.contractDataSource = contractDataSource;
-        this.dateProvider = dateProvider;
-        this.telemetryClient = telemetryClient;
-    }
-    getConfig() {
-        return pick(this.config, ...FullNodeBlockBuilderConfigKeys);
-    }
-    updateConfig(config) {
-        this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
-    }
-    async makeBlockBuilderDeps(globalVariables, fork) {
-        const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? await getDefaultAllowedSetupFunctions();
-        const contractsDB = new PublicContractsDB(this.contractDataSource);
-        const guardedFork = new GuardedMerkleTreeOperations(fork);
-        const publicTxSimulator = new TelemetryCppPublicTxSimulator(guardedFork, contractsDB, globalVariables, this.telemetryClient, PublicSimulatorConfig.from({
-            skipFeeEnforcement: false,
-            collectDebugLogs: false,
-            collectHints: false,
-            collectStatistics: false,
-            collectCallMetadata: false
-        }));
-        const processor = new PublicProcessor(globalVariables, guardedFork, contractsDB, publicTxSimulator, this.dateProvider, this.telemetryClient, undefined, this.config);
-        const validator = createValidatorForBlockBuilding(fork, this.contractDataSource, globalVariables, txPublicSetupAllowList);
-        return {
-            processor,
-            validator
-        };
-    }
-    async syncToPreviousBlock(parentBlockNumber, timeout) {
-        await retryUntil(()=>this.worldState.syncImmediate(parentBlockNumber, true).then((syncedTo)=>syncedTo >= parentBlockNumber), 'sync to previous block', timeout, 0.1);
-        log.debug(`Synced to previous block ${parentBlockNumber}`);
-    }
-    async buildBlock(pendingTxs, l1ToL2Messages, globalVariables, opts, suppliedFork) {
-        const parentBlockNumber = BlockNumber(globalVariables.blockNumber - 1);
-        const syncTimeout = opts.deadline ? (opts.deadline.getTime() - this.dateProvider.now()) / 1000 : undefined;
-        await this.syncToPreviousBlock(parentBlockNumber, syncTimeout);
-        const fork = suppliedFork ?? await this.worldState.fork(parentBlockNumber);
-        try {
-            const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, fork);
-            const res = await buildBlock(pendingTxs, l1ToL2Messages, globalVariables, opts, fork, processor, validator, this.config, this.dateProvider, this.telemetryClient);
-            return res;
-        } finally{
-            // If the fork was supplied, we don't close it.
-            // Otherwise, we wait a bit to close the fork we just created,
-            // since the processor may still be working on a dangling tx
-            // which was interrupted due to the processingDeadline being hit.
-            if (!suppliedFork) {
-                // eslint-disable-next-line @typescript-eslint/no-misused-promises
-                setTimeout(async ()=>{
-                    try {
-                        await fork.close();
-                    } catch (err) {
-                        // This can happen if the sequencer is stopped before we hit this timeout.
-                        log.warn(`Error closing forks for block processing`, err);
-                    }
-                }, 5000);
-            }
-        }
-    }
-    getFork(blockNumber) {
-        return this.worldState.fork(blockNumber);
-    }
-}

package/dest/tx_validator/nullifier_cache.d.ts

@@ -1,14 +0,0 @@
-import type { NullifierSource } from '@aztec/p2p';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
-/**
- * Implements a nullifier source by checking a DB and an in-memory collection.
- * Intended for validating transactions as they are added to a block.
- */
-export declare class NullifierCache implements NullifierSource {
-    private db;
-    nullifiers: Set<string>;
-    constructor(db: MerkleTreeReadOperations);
-    nullifiersExist(nullifiers: Buffer[]): Promise<boolean[]>;
-    addNullifiers(nullifiers: Buffer[]): void;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGlmaWVyX2NhY2hlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHhfdmFsaWRhdG9yL251bGxpZmllcl9jYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDbEQsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUdoRjs7O0dBR0c7QUFDSCxxQkFBYSxjQUFlLFlBQVcsZUFBZTtJQUd4QyxPQUFPLENBQUMsRUFBRTtJQUZ0QixVQUFVLEVBQUUsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRXhCLFlBQW9CLEVBQUUsRUFBRSx3QkFBd0IsRUFFL0M7SUFFWSxlQUFlLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQU9yRTtJQUVNLGFBQWEsQ0FBQyxVQUFVLEVBQUUsTUFBTSxFQUFFLFFBSXhDO0NBQ0YifQ==

package/dest/tx_validator/nullifier_cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nullifier_cache.d.ts","sourceRoot":"","sources":["../../src/tx_validator/nullifier_cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF;;;GAGG;AACH,qBAAa,cAAe,YAAW,eAAe;IAGxC,OAAO,CAAC,EAAE;IAFtB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAExB,YAAoB,EAAE,EAAE,wBAAwB,EAE/C;IAEY,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAOrE;IAEM,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,QAIxC;CACF"}