@aztec/world-state 0.57.0 → 0.59.0

package/src/native/native_world_state_instance.ts

@@ -0,0 +1,262 @@
+import { MerkleTreeId } from '@aztec/circuit-types';
+import {
+  ARCHIVE_HEIGHT,
+  Fr,
+  GeneratorIndex,
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  NOTE_HASH_TREE_HEIGHT,
+  NULLIFIER_TREE_HEIGHT,
+  PUBLIC_DATA_TREE_HEIGHT,
+} from '@aztec/circuits.js';
+import { createDebugLogger, fmtLogData } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import { Timer } from '@aztec/foundation/timer';
+
+import assert from 'assert';
+import bindings from 'bindings';
+import { Decoder, Encoder, addExtension } from 'msgpackr';
+import { cpus } from 'os';
+import { isAnyArrayBuffer } from 'util/types';
+
+import {
+  MessageHeader,
+  TypedMessage,
+  WorldStateMessageType,
+  type WorldStateRequest,
+  type WorldStateResponse,
+} from './message.js';
+
+// small extension to pack an NodeJS Fr instance to a representation that the C++ code can understand
+// this only works for writes. Unpacking from C++ can't create Fr instances because the data is passed
+// as raw, untagged, buffers. On the NodeJS side we don't know what the buffer represents
+// Adding a tag would be a solution, but it would have to be done on both sides and it's unclear where else
+// C++ fr instances are sent/received/stored.
+addExtension({
+  Class: Fr,
+  write: fr => fr.toBuffer(),
+});
+
+export interface NativeInstance {
+  call(msg: Buffer | Uint8Array): Promise<any>;
+}
+
+const NATIVE_LIBRARY_NAME = 'world_state_napi';
+const NATIVE_CLASS_NAME = 'WorldState';
+
+const NATIVE_MODULE = bindings(NATIVE_LIBRARY_NAME);
+const MAX_WORLD_STATE_THREADS = 16;
+
+export interface NativeWorldStateInstance {
+  call<T extends WorldStateMessageType>(messageType: T, body: WorldStateRequest[T]): Promise<WorldStateResponse[T]>;
+}
+
+/**
+ * Strongly-typed interface to access the WorldState class in the native world_state_napi module.
+ */
+export class NativeWorldState implements NativeWorldStateInstance {
+  private open = true;
+
+  /** Each message needs a unique ID */
+  private nextMessageId = 0;
+
+  /** A long-lived msgpack encoder */
+  private encoder = new Encoder({
+    // always encode JS objects as MessagePack maps
+    // this makes it compatible with other MessagePack decoders
+    useRecords: false,
+    int64AsType: 'bigint',
+  });
+
+  /** A long-lived msgpack decoder */
+  private decoder = new Decoder({
+    useRecords: false,
+    int64AsType: 'bigint',
+  });
+
+  /** The actual native instance */
+  private instance: any;
+
+  /** Calls to the same instance are serialized */
+  private queue = new SerialQueue();
+
+  /** Creates a new native WorldState instance */
+  constructor(dataDir: string, private log = createDebugLogger('aztec:world-state:database')) {
+    this.instance = new NATIVE_MODULE[NATIVE_CLASS_NAME](
+      dataDir,
+      {
+        [MerkleTreeId.NULLIFIER_TREE]: NULLIFIER_TREE_HEIGHT,
+        [MerkleTreeId.NOTE_HASH_TREE]: NOTE_HASH_TREE_HEIGHT,
+        [MerkleTreeId.PUBLIC_DATA_TREE]: PUBLIC_DATA_TREE_HEIGHT,
+        [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: L1_TO_L2_MSG_TREE_HEIGHT,
+        [MerkleTreeId.ARCHIVE]: ARCHIVE_HEIGHT,
+      },
+      {
+        [MerkleTreeId.NULLIFIER_TREE]: 2 * MAX_NULLIFIERS_PER_TX,
+        [MerkleTreeId.PUBLIC_DATA_TREE]: 2 * MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+      },
+      GeneratorIndex.BLOCK_HASH,
+      10 * 1024 * 1024, // 10 GB per tree (in KB)
+      Math.min(cpus().length, MAX_WORLD_STATE_THREADS),
+    );
+    this.queue.start();
+  }
+
+  /**
+   * Sends a message to the native instance and returns the response.
+   * @param messageType - The type of message to send
+   * @param body - The message body
+   * @returns The response to the message
+   */
+  public call<T extends WorldStateMessageType>(
+    messageType: T,
+    body: WorldStateRequest[T],
+  ): Promise<WorldStateResponse[T]> {
+    return this.queue.put(() => {
+      assert.notEqual(messageType, WorldStateMessageType.CLOSE, 'Use close() to close the native instance');
+      assert.equal(this.open, true, 'Native instance is closed');
+      return this._sendMessage(messageType, body);
+    });
+  }
+
+  /**
+   * Stops the native instance.
+   */
+  public async close(): Promise<void> {
+    if (!this.open) {
+      return;
+    }
+    this.open = false;
+    await this._sendMessage(WorldStateMessageType.CLOSE, undefined);
+    await this.queue.end();
+  }
+
+  private async _sendMessage<T extends WorldStateMessageType>(
+    messageType: T,
+    body: WorldStateRequest[T],
+  ): Promise<WorldStateResponse[T]> {
+    const messageId = this.nextMessageId++;
+    if (body) {
+      let data: Record<string, any> = {};
+      if ('treeId' in body) {
+        data['treeId'] = MerkleTreeId[body.treeId];
+      }
+
+      if ('revision' in body) {
+        data = { ...data, ...body.revision };
+      }
+
+      if ('forkId' in body) {
+        data['forkId'] = body.forkId;
+      }
+
+      if ('blockNumber' in body) {
+        data['blockNumber'] = body.blockNumber;
+      }
+
+      if ('toBlockNumber' in body) {
+        data['toBlockNumber'] = body.toBlockNumber;
+      }
+
+      if ('leafIndex' in body) {
+        data['leafIndex'] = body.leafIndex;
+      }
+
+      if ('blockHeaderHash' in body) {
+        data['blockHeaderHash'] = '0x' + body.blockHeaderHash.toString('hex');
+      }
+
+      if ('leaf' in body) {
+        if (Buffer.isBuffer(body.leaf)) {
+          data['leaf'] = '0x' + body.leaf.toString('hex');
+        } else if ('slot' in body.leaf) {
+          data['slot'] = '0x' + body.leaf.slot.toString('hex');
+          data['value'] = '0x' + body.leaf.value.toString('hex');
+        } else {
+          data['nullifier'] = '0x' + body.leaf.value.toString('hex');
+        }
+      }
+
+      if ('leaves' in body) {
+        data['leavesCount'] = body.leaves.length;
+      }
+
+      // sync operation
+      if ('paddedNoteHashes' in body) {
+        data['notesCount'] = body.paddedNoteHashes.length;
+        data['nullifiersCount'] = body.paddedNullifiers.length;
+        data['l1ToL2MessagesCount'] = body.paddedL1ToL2Messages.length;
+        data['publicDataWritesCount'] = body.batchesOfPaddedPublicDataWrites.reduce(
+          (acc, batch) => acc + batch.length,
+          0,
+        );
+      }
+
+      this.log.debug(`Calling messageId=${messageId} ${WorldStateMessageType[messageType]} with ${fmtLogData(data)}`);
+    } else {
+      this.log.debug(`Calling messageId=${messageId} ${WorldStateMessageType[messageType]}`);
+    }
+
+    const timer = new Timer();
+
+    const request = new TypedMessage(messageType, new MessageHeader({ messageId }), body);
+    const encodedRequest = this.encoder.encode(request);
+    const encodingDuration = timer.ms();
+
+    let encodedResponse: any;
+    try {
+      encodedResponse = await this.instance.call(encodedRequest);
+    } catch (error) {
+      this.log.error(`Call messageId=${messageId} ${WorldStateMessageType[messageType]} failed: ${error}`);
+      throw error;
+    }
+
+    const callDuration = timer.ms() - encodingDuration;
+
+    const buf = Buffer.isBuffer(encodedResponse)
+      ? encodedResponse
+      : isAnyArrayBuffer(encodedResponse)
+      ? Buffer.from(encodedResponse)
+      : encodedResponse;
+
+    if (!Buffer.isBuffer(buf)) {
+      throw new TypeError(
+        'Invalid encoded response: expected Buffer or ArrayBuffer, got ' +
+          (encodedResponse === null ? 'null' : typeof encodedResponse),
+      );
+    }
+
+    const decodedResponse = this.decoder.unpack(buf);
+    if (!TypedMessage.isTypedMessageLike(decodedResponse)) {
+      throw new TypeError(
+        'Invalid response: expected TypedMessageLike, got ' +
+          (decodedResponse === null ? 'null' : typeof decodedResponse),
+      );
+    }
+
+    const response = TypedMessage.fromMessagePack<T, WorldStateResponse[T]>(decodedResponse);
+    const decodingDuration = timer.ms() - callDuration;
+    const totalDuration = timer.ms();
+    this.log.debug(
+      `Call messageId=${messageId} ${WorldStateMessageType[messageType]} took (ms) ${fmtLogData({
+        totalDuration,
+        encodingDuration,
+        callDuration,
+        decodingDuration,
+      })}`,
+    );
+
+    if (response.header.requestId !== request.header.messageId) {
+      throw new Error(
+        'Response ID does not match request: ' + response.header.requestId + ' != ' + request.header.messageId,
+      );
+    }
+
+    if (response.msgType !== messageType) {
+      throw new Error('Invalid response message type: ' + response.msgType + ' != ' + messageType);
+    }
+
+    return response.value;
+  }
+}

package/src/synchronizer/config.ts

@@ -5,11 +5,11 @@ export interface WorldStateConfig {
   /** The frequency in which to check. */
   worldStateBlockCheckIntervalMS: number;
 
-  /** Size of queue of L2 blocks to store. */
-  l2QueueSize: number;
-
   /** Whether to follow only the proven chain. */
   worldStateProvenBlocksOnly: boolean;
+
+  /** Size of the batch for each get-blocks request from the synchronizer to the archiver. */
+  worldStateBlockRequestBatchSize?: number;
 }
 
 export const worldStateConfigMappings: ConfigMappingsType<WorldStateConfig> = {
@@ -19,17 +19,16 @@ export const worldStateConfigMappings: ConfigMappingsType<WorldStateConfig> = {
     defaultValue: 100,
     description: 'The frequency in which to check.',
   },
-  l2QueueSize: {
-    env: 'WS_L2_BLOCK_QUEUE_SIZE',
-    parseEnv: (val: string) => +val,
-    defaultValue: 1000,
-    description: 'Size of queue of L2 blocks to store.',
-  },
   worldStateProvenBlocksOnly: {
     env: 'WS_PROVEN_BLOCKS_ONLY',
     description: 'Whether to follow only the proven chain.',
     ...booleanConfigHelper(),
   },
+  worldStateBlockRequestBatchSize: {
+    env: 'WS_BLOCK_REQUEST_BATCH_SIZE',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description: 'Size of the batch for each get-blocks request from the synchronizer to the archiver.',
+  },
 };
 
 /**

package/src/synchronizer/factory.ts

@@ -2,7 +2,9 @@ import { type L1ToL2MessageSource, type L2BlockSource } from '@aztec/circuit-typ
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type DataStoreConfig, createStore } from '@aztec/kv-store/utils';
 import { type TelemetryClient } from '@aztec/telemetry-client';
+import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
+import { NativeWorldStateService } from '../native/native_world_state.js';
 import { MerkleTrees } from '../world-state-db/merkle_trees.js';
 import { type WorldStateConfig } from './config.js';
 import { ServerWorldStateSynchronizer } from './server_world_state_synchronizer.js';
@@ -12,7 +14,22 @@ export async function createWorldStateSynchronizer(
   l2BlockSource: L2BlockSource & L1ToL2MessageSource,
   client: TelemetryClient,
 ) {
-  const store = await createStore('world-state', config, createDebugLogger('aztec:world-state:lmdb'));
-  const merkleTrees = await MerkleTrees.new(store, client);
-  return new ServerWorldStateSynchronizer(store, merkleTrees, l2BlockSource, config);
+  const merkleTrees = await createWorldState(config, client);
+  return new ServerWorldStateSynchronizer(merkleTrees, l2BlockSource, config);
+}
+
+export async function createWorldState(config: DataStoreConfig, client: TelemetryClient = new NoopTelemetryClient()) {
+  const merkleTrees = ['true', '1'].includes(process.env.USE_LEGACY_WORLD_STATE ?? '')
+    ? await MerkleTrees.new(
+        await createStore('world-state', config, createDebugLogger('aztec:world-state:lmdb')),
+        client,
+      )
+    : config.dataDirectory
+    ? await NativeWorldStateService.new(config.l1Contracts.rollupAddress, config.dataDirectory)
+    : await NativeWorldStateService.tmp(
+        config.l1Contracts.rollupAddress,
+        !['true', '1'].includes(process.env.DEBUG_WORLD_STATE!),
+      );
+
+  return merkleTrees;
 }