@aztec-labs/pxe 6.0.0-nightly.20260829

package/dest/entrypoints/server/circuit_recording/file_circuit_recorder.js

@@ -0,0 +1,131 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { CircuitRecorder } from './circuit_recorder.js';
+export class FileCircuitRecorder extends CircuitRecorder {
+    recordDir;
+    #fileState;
+    constructor(recordDir, logger){
+        super(logger), this.recordDir = recordDir, this.#fileState = new WeakMap();
+    }
+    async onStart(recording) {
+        const recordingStringWithoutClosingBracket = JSON.stringify({
+            ...recording,
+            parent: undefined,
+            oracleCalls: undefined
+        }, null, 2).slice(0, -2);
+        try {
+            // Check if the recording directory exists and is a directory
+            const stats = await fs.stat(this.recordDir);
+            if (!stats.isDirectory()) {
+                throw new Error(`Recording path ${this.recordDir} exists but is not a directory`);
+            }
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                // The directory does not exist so we create it
+                await fs.mkdir(this.recordDir, {
+                    recursive: true
+                });
+            } else {
+                throw err;
+            }
+        }
+        const filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(this.recordDir, recording.circuitName, recording.functionName, recordingStringWithoutClosingBracket);
+        this.#fileState.set(recording, {
+            filePath,
+            isFirstCall: true
+        });
+    }
+    /**
+   * Computes a unique file path for the recording by trying different counter values.
+   * This is needed because multiple recordings of the same circuit could be happening simultaneously or an older
+   * recording might be present.
+   * @param recordDir - Directory to store the recording
+   * @param circuitName - Name of the circuit
+   * @param functionName - Name of the circuit function
+   * @param recordingContent - Initial recording content
+   * @returns A unique file path for the recording
+   */ static async #computeFilePathAndStoreInitialRecording(recordDir, circuitName, functionName, recordingContent) {
+        let counter = 0;
+        while(true){
+            try {
+                const filePath = getFilePath(recordDir, circuitName, functionName, counter);
+                // Write the initial recording content to the file
+                await fs.writeFile(filePath, recordingContent + ',\n  "oracleCalls": [\n', {
+                    flag: 'wx'
+                });
+                return filePath;
+            } catch (err) {
+                if (err.code === 'EEXIST') {
+                    counter++;
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    /**
+   * Records a single oracle/foreign call with its inputs and outputs.
+   * @param name - Name of the call
+   * @param inputs - Input arguments
+   * @param outputs - Output results
+   */ async recordCall(name, inputs, outputs, time) {
+        const entry = await super.recordCall(name, inputs, outputs, time);
+        const recording = this.currentRecording();
+        const state = recording && this.#fileState.get(recording);
+        if (state) {
+            try {
+                const prefix = state.isFirstCall ? '    ' : '    ,';
+                state.isFirstCall = false;
+                await fs.appendFile(state.filePath, prefix + JSON.stringify(entry) + '\n');
+            } catch (err) {
+                this.logger.error('Failed to log circuit call', {
+                    error: err
+                });
+            }
+        }
+        return entry;
+    }
+    /** Closes the recording file with the trailing brackets so the JSON parses. */ async onFinish(recording) {
+        const state = this.#fileState.get(recording);
+        if (!state) {
+            return;
+        }
+        try {
+            await fs.appendFile(state.filePath, '  ]\n}\n');
+        } catch (err) {
+            this.logger.error('Failed to finalize recording file', {
+                error: err
+            });
+        }
+    }
+    /** Closes the recording file with the execution error and trailing brackets so the JSON parses. */ async onError(recording, error) {
+        const state = this.#fileState.get(recording);
+        if (!state) {
+            return;
+        }
+        try {
+            await fs.appendFile(state.filePath, '  ],\n');
+            await fs.appendFile(state.filePath, `  "error": ${JSON.stringify(error)}\n`);
+            await fs.appendFile(state.filePath, '}\n');
+        } catch (err) {
+            this.logger.error('Failed to finalize recording file with error', {
+                error: err
+            });
+        }
+    }
+}
+/**
+ * Generates a file path for storing circuit recordings. The format of the filename is:
+ * `circuit_name_circuit_function_name_YYYY-MM-DD_N.json` where N is a counter to ensure unique filenames.
+ * @param recordDir - Base directory for recordings
+ * @param circuitName - Name of the circuit
+ * @param functionName - Name of the circuit function
+ * @param counter - Counter to ensure unique filenames. This is expected to be incremented in a loop until there is no
+ * existing file with the same name.
+ * @returns A file path for the recording.
+ */ function getFilePath(recordDir, circuitName, functionName, counter) {
+    const date = new Date();
+    const formattedDate = date.toISOString().split('T')[0];
+    const filename = `${circuitName}_${functionName}_${formattedDate}_${counter}.json`;
+    return path.join(recordDir, filename);
+}

package/dest/entrypoints/server/circuit_recording/memory_circuit_recorder.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import { CircuitRecorder } from './circuit_recorder.js';
+/**
+ * In memory circuit recorder uses the default implementation. This is kept
+ * while we decide the fate of the FileCircuitRecorder.
+ */
+export declare class MemoryCircuitRecorder extends CircuitRecorder {
+    constructor(logger?: Logger);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtb3J5X2NpcmN1aXRfcmVjb3JkZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbnRyeXBvaW50cy9zZXJ2ZXIvY2lyY3VpdF9yZWNvcmRpbmcvbWVtb3J5X2NpcmN1aXRfcmVjb3JkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFekQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXhEOzs7R0FHRztBQUNILHFCQUFhLHFCQUFzQixTQUFRLGVBQWU7SUFDeEQsWUFBWSxNQUFNLENBQUMsRUFBRSxNQUFNLEVBRTFCO0NBQ0YifQ==

package/dest/entrypoints/server/circuit_recording/memory_circuit_recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory_circuit_recorder.d.ts","sourceRoot":"","sources":["../../../../src/entrypoints/server/circuit_recording/memory_circuit_recorder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,eAAe;IACxD,YAAY,MAAM,CAAC,EAAE,MAAM,EAE1B;CACF"}

package/dest/entrypoints/server/circuit_recording/memory_circuit_recorder.js

@@ -0,0 +1,9 @@
+import { CircuitRecorder } from './circuit_recorder.js';
+/**
+ * In memory circuit recorder uses the default implementation. This is kept
+ * while we decide the fate of the FileCircuitRecorder.
+ */ export class MemoryCircuitRecorder extends CircuitRecorder {
+    constructor(logger){
+        super(logger);
+    }
+}

package/dest/entrypoints/server/circuit_recording/simulator_recorder_wrapper.d.ts

@@ -0,0 +1,18 @@
+import type { ForeignCallHandler } from '@aztec/noir-acvm_js';
+import type { ACIRCallback, ACIRExecutionResult, ACVMSuccess, ACVMWitness, CircuitSimulator } from '@aztec-labs/simulator/client';
+import type { FunctionArtifactWithContractName } from '@aztec-labs/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec-labs/stdlib/noir';
+import type { CircuitRecorder } from './circuit_recorder.js';
+/**
+ * Takes a circuit simulator and wraps it in a circuit recorder. See CircuitRecorder for more details on how circuit
+ * recording works.
+ */
+export declare class SimulatorRecorderWrapper implements CircuitSimulator {
+    #private;
+    private simulator;
+    private recorder;
+    constructor(simulator: CircuitSimulator, recorder: CircuitRecorder);
+    executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler | undefined): Promise<ACVMSuccess>;
+    executeUserCircuit(input: ACVMWitness, artifact: FunctionArtifactWithContractName, callback: ACIRCallback): Promise<ACIRExecutionResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltdWxhdG9yX3JlY29yZGVyX3dyYXBwZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbnRyeXBvaW50cy9zZXJ2ZXIvY2lyY3VpdF9yZWNvcmRpbmcvc2ltdWxhdG9yX3JlY29yZGVyX3dyYXBwZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUU5RCxPQUFPLEtBQUssRUFDVixZQUFZLEVBRVosbUJBQW1CLEVBQ25CLFdBQVcsRUFDWCxXQUFXLEVBQ1gsZ0JBQWdCLEVBQ2pCLE1BQU0sOEJBQThCLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMvRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRTNFLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRTdEOzs7R0FHRztBQUNILHFCQUFhLHdCQUF5QixZQUFXLGdCQUFnQjs7SUFFN0QsT0FBTyxDQUFDLFNBQVM7SUFDakIsT0FBTyxDQUFDLFFBQVE7SUFGbEIsWUFDVSxTQUFTLEVBQUUsZ0JBQWdCLEVBQzNCLFFBQVEsRUFBRSxlQUFlLEVBQy9CO0lBRUosc0JBQXNCLENBQ3BCLEtBQUssRUFBRSxXQUFXLEVBQ2xCLFFBQVEsRUFBRSwyQkFBMkIsRUFDckMsUUFBUSxFQUFFLGtCQUFrQixHQUFHLFNBQVMsR0FDdkMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQVd0QjtJQUVELGtCQUFrQixDQUNoQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsZ0NBQWdDLEVBQzFDLFFBQVEsRUFBRSxZQUFZLEdBQ3JCLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQVM5QjtDQWtDRiJ9

package/dest/entrypoints/server/circuit_recording/simulator_recorder_wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulator_recorder_wrapper.d.ts","sourceRoot":"","sources":["../../../../src/entrypoints/server/circuit_recording/simulator_recorder_wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,OAAO,KAAK,EACV,YAAY,EAEZ,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,wBAAwB,CAAC;AAC/E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAE3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,gBAAgB;;IAE7D,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;IAFlB,YACU,SAAS,EAAE,gBAAgB,EAC3B,QAAQ,EAAE,eAAe,EAC/B;IAEJ,sBAAsB,CACpB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,OAAO,CAAC,WAAW,CAAC,CAWtB;IAED,kBAAkB,CAChB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAS9B;CAkCF"}

package/dest/entrypoints/server/circuit_recording/simulator_recorder_wrapper.js

@@ -0,0 +1,41 @@
+/**
+ * Takes a circuit simulator and wraps it in a circuit recorder. See CircuitRecorder for more details on how circuit
+ * recording works.
+ */ export class SimulatorRecorderWrapper {
+    simulator;
+    recorder;
+    constructor(simulator, recorder){
+        this.simulator = simulator;
+        this.recorder = recorder;
+    }
+    executeProtocolCircuit(input, artifact, callback) {
+        const bytecode = Buffer.from(artifact.bytecode, 'base64');
+        return this.#simulate((wrappedCallback)=>this.simulator.executeProtocolCircuit(input, artifact, wrappedCallback), input, bytecode, artifact.name, 'main', callback);
+    }
+    executeUserCircuit(input, artifact, callback) {
+        return this.#simulate((wrappedCallback)=>this.simulator.executeUserCircuit(input, artifact, wrappedCallback), input, artifact.bytecode, artifact.contractName, artifact.name, callback);
+    }
+    async #simulate(simulateFn, input, bytecode, contractName, functionName, callback) {
+        // If a callback was provided, we wrap it so that its oracle calls are recorded. The wrapped callback reads the
+        // active recording lazily, so it picks up the recording opened by record() below.
+        const wrappedCallback = this.recorder.wrapCallback(callback);
+        // record() opens a recording for this circuit, runs the simulation within it, and finalizes it. A simulation
+        // failure is re-thrown unchanged, so recorder bookkeeping never masks the underlying error.
+        const { result, recording } = await this.recorder.record({
+            input,
+            bytecode,
+            circuitName: contractName,
+            functionName
+        }, ()=>simulateFn(wrappedCallback));
+        result.oracles = recording.oracleCalls.reduce((acc, { time, name })=>{
+            if (!acc[name]) {
+                acc[name] = {
+                    times: []
+                };
+            }
+            acc[name].times.push(time);
+            return acc;
+        }, {});
+        return result;
+    }
+}

package/dest/entrypoints/server/index.d.ts

@@ -0,0 +1,17 @@
+export { type AccountPrivacyKeys, type AccountPrivacySecretKeys } from '@aztec-labs/key-store';
+export * from '../../notes_filter.js';
+export * from '../../pxe.js';
+export * from '../../config/index.js';
+export * from '../../error_enriching.js';
+export * from '../../storage/index.js';
+export * from './utils.js';
+export * from './store.js';
+export { NoteService } from '../../notes/note_service.js';
+export { ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR } from '../../oracle_version.js';
+export { type PXECreationOptions } from '../pxe_creation_options.js';
+export { type ChangeSetId, StagedWriteCoordinator } from '../../storage/staged_write_coordinator.js';
+export { runOperation, type OperationContributor } from '../../operation_lifecycle.js';
+export { ContractSyncService } from '../../contract/contract_sync_service.js';
+export { ContractClassService } from '../../contract/contract_class_service.js';
+export { AnchoredContractData } from '../../contract_function_simulator/anchored_contract_data.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbnRyeXBvaW50cy9zZXJ2ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssa0JBQWtCLEVBQUUsS0FBSyx3QkFBd0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRS9GLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQzFELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3JGLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDckUsT0FBTyxFQUFFLEtBQUssV0FBVyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDckcsT0FBTyxFQUFFLFlBQVksRUFBRSxLQUFLLG9CQUFvQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDdkYsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDOUUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDaEYsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sNkRBQTZELENBQUMifQ==

package/dest/entrypoints/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAE/F,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,EAAE,KAAK,WAAW,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACrG,OAAO,EAAE,YAAY,EAAE,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACvF,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,6DAA6D,CAAC"}

package/dest/entrypoints/server/index.js

@@ -0,0 +1,14 @@
+export * from '../../notes_filter.js';
+export * from '../../pxe.js';
+export * from '../../config/index.js';
+export * from '../../error_enriching.js';
+export * from '../../storage/index.js';
+export * from './utils.js';
+export * from './store.js';
+export { NoteService } from '../../notes/note_service.js';
+export { ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR } from '../../oracle_version.js';
+export { StagedWriteCoordinator } from '../../storage/staged_write_coordinator.js';
+export { runOperation } from '../../operation_lifecycle.js';
+export { ContractSyncService } from '../../contract/contract_sync_service.js';
+export { ContractClassService } from '../../contract/contract_class_service.js';
+export { AnchoredContractData } from '../../contract_function_simulator/anchored_contract_data.js';

package/dest/entrypoints/server/store.d.ts

@@ -0,0 +1,18 @@
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type LoggerBindings } from '@aztec-labs/foundation/log';
+import { type AztecLMDBStoreV2 } from '@aztec-labs/kv-store/lmdb-v2';
+/** Location and identity inputs for opening an identity-partitioned PXE-side store. */
+export type IdentityStoreConfig = {
+    dataDirectory: string;
+    /** Maximum LMDB map size in KB. When omitted, the kv-store default map size applies. */
+    dataStoreMapSizeKb?: number;
+    l1ChainId: number;
+    rollupAddress: EthAddress;
+};
+/**
+ * Opens the persistent LMDB store selected by `name` and identity triple `(l1ChainId, rollupAddress, schemaVersion)`.
+ * A store exists per identity: reopening with the same identity returns the same data, a different identity selects
+ * a different (possibly fresh) store. Callers wanting an ephemeral store use `openTmpStore` explicitly instead.
+ */
+export declare function openStore(name: string, schemaVersion: number, config: IdentityStoreConfig, bindings?: LoggerBindings): Promise<AztecLMDBStoreV2>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbnRyeXBvaW50cy9zZXJ2ZXIvc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDckUsT0FBTyxFQUFFLEtBQUssY0FBYyxFQUFnQixNQUFNLDRCQUE0QixDQUFDO0FBQy9FLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUFlLE1BQU0sOEJBQThCLENBQUM7QUFNbEYsdUZBQXVGO0FBQ3ZGLE1BQU0sTUFBTSxtQkFBbUIsR0FBRztJQUNoQyxhQUFhLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLHdGQUF3RjtJQUN4RixrQkFBa0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUM1QixTQUFTLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLGFBQWEsRUFBRSxVQUFVLENBQUM7Q0FDM0IsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBc0IsU0FBUyxDQUM3QixJQUFJLEVBQUUsTUFBTSxFQUNaLGFBQWEsRUFBRSxNQUFNLEVBQ3JCLE1BQU0sRUFBRSxtQkFBbUIsRUFDM0IsUUFBUSxDQUFDLEVBQUUsY0FBYyxHQUN4QixPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FrQjNCIn0=

package/dest/entrypoints/server/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/server/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,KAAK,cAAc,EAAgB,MAAM,4BAA4B,CAAC;AAC/E,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,8BAA8B,CAAC;AAMlF,uFAAuF;AACvF,MAAM,MAAM,mBAAmB,GAAG;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,wFAAwF;IACxF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,UAAU,CAAC;CAC3B,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,gBAAgB,CAAC,CAkB3B"}

package/dest/entrypoints/server/store.js

@@ -0,0 +1,28 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { openStoreAt } from '@aztec-labs/kv-store/lmdb-v2';
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+import { storeIdentitySlug } from '../../storage/store_identity.js';
+/**
+ * Opens the persistent LMDB store selected by `name` and identity triple `(l1ChainId, rollupAddress, schemaVersion)`.
+ * A store exists per identity: reopening with the same identity returns the same data, a different identity selects
+ * a different (possibly fresh) store. Callers wanting an ephemeral store use `openTmpStore` explicitly instead.
+ */ export async function openStore(name, schemaVersion, config, bindings) {
+    // Stores live under `<dataDirectory>/<name>-stores/<l1ChainId>-<rollupAddress>-v<schemaVersion>`, a sibling of the
+    // legacy `<dataDirectory>/<name>` directory: older binaries reset the legacy directory on a rollup mismatch, so
+    // per-identity stores must not nest inside it.
+    const subDir = join(config.dataDirectory, `${name}-stores`, storeIdentitySlug({
+        l1ChainId: config.l1ChainId,
+        rollupAddress: config.rollupAddress,
+        schemaVersion
+    }));
+    await mkdir(subDir, {
+        recursive: true
+    });
+    createLogger(`pxe:data:${name}`, bindings).info(`Opening ${name} data store (LMDB v2)`, {
+        storeName: name,
+        subDir,
+        dataStoreMapSizeKb: config.dataStoreMapSizeKb
+    });
+    return openStoreAt(subDir, config.dataStoreMapSizeKb, undefined, bindings);
+}

package/dest/entrypoints/server/utils.d.ts

@@ -0,0 +1,9 @@
+import type { L1ContractAddresses } from '@aztec-labs/ethereum/l1-contract-addresses';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+import type { PXEConfig } from '../../config/index.js';
+import { PXE } from '../../pxe.js';
+import { type PXECreationOptions } from '../pxe_creation_options.js';
+type PXEConfigWithoutDefaults = Omit<PXEConfig, 'l1ChainId' | 'l2BlockBatchSize' | 'rollupVersion' | keyof L1ContractAddresses>;
+export declare function createPXE(aztecNode: AztecNode, config: PXEConfigWithoutDefaults, options?: PXECreationOptions): Promise<PXE>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbnRyeXBvaW50cy9zZXJ2ZXIvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQVF0RixPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUV0RSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRW5DLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUF5QixNQUFNLDRCQUE0QixDQUFDO0FBTTVGLEtBQUssd0JBQXdCLEdBQUcsSUFBSSxDQUNsQyxTQUFTLEVBQ1QsV0FBVyxHQUFHLGtCQUFrQixHQUFHLGVBQWUsR0FBRyxNQUFNLG1CQUFtQixDQUMvRSxDQUFDO0FBRUYsd0JBQXNCLFNBQVMsQ0FDN0IsU0FBUyxFQUFFLFNBQVMsRUFDcEIsTUFBTSxFQUFFLHdCQUF3QixFQUNoQyxPQUFPLEdBQUUsa0JBQW9DLGdCQTBFOUMifQ==

package/dest/entrypoints/server/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/server/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAQtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAEnC,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,4BAA4B,CAAC;AAM5F,KAAK,wBAAwB,GAAG,IAAI,CAClC,SAAS,EACT,WAAW,GAAG,kBAAkB,GAAG,eAAe,GAAG,MAAM,mBAAmB,CAC/E,CAAC;AAEF,wBAAsB,SAAS,CAC7B,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,wBAAwB,EAChC,OAAO,GAAE,kBAAoC,gBA0E9C"}

package/dest/entrypoints/server/utils.js

@@ -0,0 +1,84 @@
+import { BBBundlePrivateKernelProver } from '@aztec-labs/bb-prover/client/bundle';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { openTmpStore } from '@aztec-labs/kv-store/lmdb-v2';
+import { BundledProtocolContractsProvider } from '@aztec-labs/protocol-contracts/providers/bundle';
+import { WASMSimulator } from '@aztec-labs/simulator/client';
+import { getStandardAuthRegistry } from '@aztec-labs/standard-contracts/auth-registry';
+import { getStandardHandshakeRegistry } from '@aztec-labs/standard-contracts/handshake-registry';
+import { getStandardMultiCallEntrypoint } from '@aztec-labs/standard-contracts/multi-call-entrypoint';
+import { PXE } from '../../pxe.js';
+import { PXE_DATA_SCHEMA_VERSION } from '../../storage/index.js';
+import { isPrivateKernelProver } from '../pxe_creation_options.js';
+import { FileCircuitRecorder } from './circuit_recording/file_circuit_recorder.js';
+import { MemoryCircuitRecorder } from './circuit_recording/memory_circuit_recorder.js';
+import { SimulatorRecorderWrapper } from './circuit_recording/simulator_recorder_wrapper.js';
+import { openStore } from './store.js';
+export async function createPXE(aztecNode, config, options = {
+    loggers: {}
+}) {
+    const actor = options.loggerActorLabel;
+    const recorderLogger = createLogger('simulator:acvm:recording', {
+        actor
+    });
+    const recorder = process.env.CIRCUIT_RECORD_DIR ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR, recorderLogger) : new MemoryCircuitRecorder(recorderLogger);
+    const simulatorLogger = createLogger('wasm-simulator', {
+        actor
+    });
+    const simulator = new SimulatorRecorderWrapper(new WASMSimulator(simulatorLogger), recorder);
+    const loggers = options.loggers ?? {};
+    const { l1ChainId, l1ContractAddresses, rollupVersion } = await aztecNode.getNodeInfo();
+    const configWithContracts = {
+        ...config,
+        ...l1ContractAddresses,
+        l1ChainId,
+        rollupVersion,
+        l2BlockBatchSize: 50
+    };
+    if (!options.store) {
+        const storeLogger = loggers.store ?? createLogger('pxe:data:lmdb', {
+            actor
+        });
+        options.store = configWithContracts.dataDirectory ? await openStore('pxe_data', PXE_DATA_SCHEMA_VERSION, {
+            dataDirectory: configWithContracts.dataDirectory,
+            dataStoreMapSizeKb: configWithContracts.dataStoreMapSizeKb,
+            l1ChainId,
+            rollupAddress: l1ContractAddresses.rollupAddress
+        }, storeLogger.getBindings()) : await openTmpStore('pxe_data', true, configWithContracts.dataStoreMapSizeKb, undefined, storeLogger.getBindings());
+    }
+    const proverLogger = loggers.prover ?? createLogger('pxe:bb:native', {
+        actor
+    });
+    let prover;
+    if (isPrivateKernelProver(options.proverOrOptions)) {
+        prover = options.proverOrOptions;
+    } else {
+        prover = new BBBundlePrivateKernelProver(simulator, {
+            ...options.proverOrOptions,
+            logger: proverLogger
+        });
+    }
+    const protocolContractsProvider = new BundledProtocolContractsProvider();
+    const preloadedContractsProvider = options.preloadedContractsProvider ?? {
+        getPreloadedContracts: async ()=>[
+                await getStandardMultiCallEntrypoint(),
+                await getStandardAuthRegistry(),
+                await getStandardHandshakeRegistry()
+            ]
+    };
+    const pxeLogger = loggers.pxe ?? createLogger('pxe:service', {
+        actor
+    });
+    const pxe = await PXE.create({
+        node: aztecNode,
+        nodeDebug: options.nodeDebug,
+        store: options.store,
+        proofCreator: prover,
+        simulator,
+        protocolContractsProvider,
+        preloadedContractsProvider,
+        config: configWithContracts,
+        loggerOrSuffix: pxeLogger,
+        hooks: options.hooks
+    });
+    return pxe;
+}

package/dest/error_enriching.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import { type SimulationError } from '@aztec-labs/stdlib/errors';
+import type { BlockHeader } from '@aztec-labs/stdlib/tx';
+import type { ContractClassService } from './contract/contract_class_service.js';
+import type { ContractStore } from './storage/contract_store/contract_store.js';
+/**
+ * Adds contract and function names to a simulation error, if they
+ * can be found in the PXE database
+ * @param err - The error to enrich.
+ */
+export declare function enrichSimulationError(err: SimulationError, contractStore: ContractStore, contractClassService: ContractClassService, anchorHeader: BlockHeader, logger: Logger): Promise<void>;
+export declare function enrichPublicSimulationError(err: SimulationError, contractStore: ContractStore, contractClassService: ContractClassService, anchorHeader: BlockHeader, logger: Logger): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JfZW5yaWNoaW5nLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZXJyb3JfZW5yaWNoaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBS3pELE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBNkIsTUFBTSwyQkFBMkIsQ0FBQztBQUM1RixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV6RCxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBRWhGOzs7O0dBSUc7QUFDSCx3QkFBc0IscUJBQXFCLENBQ3pDLEdBQUcsRUFBRSxlQUFlLEVBQ3BCLGFBQWEsRUFBRSxhQUFhLEVBQzVCLG9CQUFvQixFQUFFLG9CQUFvQixFQUMxQyxZQUFZLEVBQUUsV0FBVyxFQUN6QixNQUFNLEVBQUUsTUFBTSxpQkFxRGY7QUFFRCx3QkFBc0IsMkJBQTJCLENBQy9DLEdBQUcsRUFBRSxlQUFlLEVBQ3BCLGFBQWEsRUFBRSxhQUFhLEVBQzVCLG9CQUFvQixFQUFFLG9CQUFvQixFQUMxQyxZQUFZLEVBQUUsV0FBVyxFQUN6QixNQUFNLEVBQUUsTUFBTSxpQkEwQ2YifQ==

package/dest/error_enriching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error_enriching.d.ts","sourceRoot":"","sources":["../src/error_enriching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAKzD,OAAO,EAAE,KAAK,eAAe,EAA6B,MAAM,2BAA2B,CAAC;AAC5F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AACjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4CAA4C,CAAC;AAEhF;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,eAAe,EACpB,aAAa,EAAE,aAAa,EAC5B,oBAAoB,EAAE,oBAAoB,EAC1C,YAAY,EAAE,WAAW,EACzB,MAAM,EAAE,MAAM,iBAqDf;AAED,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,eAAe,EACpB,aAAa,EAAE,aAAa,EAC5B,oBAAoB,EAAE,oBAAoB,EAC1C,YAAY,EAAE,WAAW,EACzB,MAAM,EAAE,MAAM,iBA0Cf"}

package/dest/error_enriching.js

@@ -0,0 +1,80 @@
+import { allToCompletion } from '@aztec-labs/foundation/promise';
+import { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '@aztec-labs/simulator/client';
+import { FunctionSelector } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { isNoirCallStackUnresolved } from '@aztec-labs/stdlib/errors';
+/**
+ * Adds contract and function names to a simulation error, if they
+ * can be found in the PXE database
+ * @param err - The error to enrich.
+ */ export async function enrichSimulationError(err, contractStore, contractClassService, anchorHeader, logger) {
+    // Maps contract addresses to the set of function selectors that were in error.
+    // Map and Set do reference equality for their keys instead of value equality, so we store the string
+    // representation to get e.g. different contract address objects with the same address value to match.
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    const mentionedFunctions = new Map();
+    err.getCallStack().forEach(({ contractAddress, functionSelector })=>{
+        if (!mentionedFunctions.has(contractAddress.toString())) {
+            mentionedFunctions.set(contractAddress.toString(), new Set());
+        }
+        if (functionSelector) {
+            mentionedFunctions.get(contractAddress.toString()).add(functionSelector);
+        }
+    });
+    await allToCompletion([
+        ...mentionedFunctions.entries()
+    ].map(async ([contractAddress, fnSelectors])=>{
+        const parsedContractAddress = AztecAddress.fromStringUnsafe(contractAddress);
+        const classId = await contractClassService.getCurrentClassId(parsedContractAddress, anchorHeader);
+        const artifact = classId && await contractStore.getContractArtifact(classId);
+        if (artifact) {
+            err.enrichWithContractName(parsedContractAddress, artifact.name);
+            // Map from function selector to function name. It uses a stringified key for the same reason as mentionedFunctions.
+            const selectorToNameMap = new Map();
+            await allToCompletion(artifact.functions.map(async (fn)=>{
+                const selector = await FunctionSelector.fromNameAndParameters(fn);
+                selectorToNameMap.set(selector.toString(), fn.name);
+            }));
+            for (const fnSelector of fnSelectors){
+                if (selectorToNameMap.has(fnSelector.toString())) {
+                    err.enrichWithFunctionName(parsedContractAddress, fnSelector, selectorToNameMap.get(fnSelector.toString()));
+                } else {
+                    logger.warn(`Could not find function artifact in contract ${artifact.name} for function '${fnSelector}' when enriching error callstack`);
+                }
+            }
+        } else {
+            logger.warn(`Could not find contract in database for address: ${parsedContractAddress} when enriching error callstack`);
+        }
+    }));
+}
+export async function enrichPublicSimulationError(err, contractStore, contractClassService, anchorHeader, logger) {
+    const callStack = err.getCallStack();
+    const originalFailingFunction = callStack[callStack.length - 1];
+    if (!originalFailingFunction) {
+        throw new Error(`Original failing function not found when enriching public simulation, missing callstack`);
+    }
+    const classId = await contractClassService.getCurrentClassId(originalFailingFunction.contractAddress, anchorHeader);
+    const artifact = classId && await contractStore.getPublicFunctionArtifact(classId);
+    if (!artifact) {
+        throw new Error(`Artifact not found when enriching public simulation error. Contract address: ${originalFailingFunction.contractAddress}.`);
+    }
+    const assertionMessage = resolveAssertionMessageFromRevertData(err.revertData, artifact);
+    if (assertionMessage) {
+        err.setOriginalMessage(err.getOriginalMessage() + `${assertionMessage}`);
+    }
+    const debugInfo = await contractStore.getPublicFunctionDebugMetadata(classId);
+    const noirCallStack = err.getNoirCallStack();
+    if (debugInfo) {
+        if (isNoirCallStackUnresolved(noirCallStack)) {
+            try {
+                // Public functions are simulated as a single Brillig entry point.
+                // Thus, we can safely assume here that the Brillig function id is `0`.
+                const parsedCallStack = resolveOpcodeLocations(noirCallStack, debugInfo.debugSymbols, debugInfo.files, 0);
+                err.setNoirCallStack(parsedCallStack);
+            } catch (err) {
+                logger.warn(`Could not resolve noir call stack for ${originalFailingFunction.contractAddress.toString()}:${originalFailingFunction.functionName?.toString() ?? ''}: ${err}`);
+            }
+        }
+        await enrichSimulationError(err, contractStore, contractClassService, anchorHeader, logger);
+    }
+}

package/dest/events/event_service.d.ts

@@ -0,0 +1,30 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { InBlock } from '@aztec-labs/stdlib/block';
+import type { BlockHeader } from '@aztec-labs/stdlib/tx';
+import type { EventValidationRequest } from '../contract_function_simulator/noir-structs/event_validation_request.js';
+import { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
+import type { ChangeSetId } from '../storage/staged_write_coordinator.js';
+export declare class EventService {
+    #private;
+    private readonly anchorBlockHeader;
+    private readonly privateEventStore;
+    private readonly changeSetId;
+    private readonly log;
+    constructor(anchorBlockHeader: BlockHeader, privateEventStore: PrivateEventStore, changeSetId: ChangeSetId, log?: import("@aztec-labs/foundation/log").Logger);
+    /**
+     * Validates and stores a batch of private events against the pre-fetched onchain context of their txs.
+     *
+     * @param requests - The events to validate and store.
+     * @param scope - The scope under which the events are being stored.
+     * @param validationTxData - The onchain context of each request's tx, keyed by `TxHash.toString()`. Must contain
+     * entries for every request's txHash; missing entries are treated as a node bug and cause an error.
+     */
+    validateAndStoreEvents(requests: EventValidationRequest[], scope: AztecAddress, validationTxData: ReadonlyMap<string, EventValidationTxData>): Promise<void>;
+}
+/** The onchain context of the tx an event validation request points at: where it was mined and its nullifiers. */
+export type EventValidationTxData = InBlock & {
+    nullifiers: Fr[];
+    txIndexInBlock: number;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRfc2VydmljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2V2ZW50cy9ldmVudF9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRzlELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXhELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLHNCQUFzQixFQUFFLE1BQU0seUVBQXlFLENBQUM7QUFDdEgsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdURBQXVELENBQUM7QUFDMUYsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFFMUUscUJBQWEsWUFBWTs7SUFFckIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxXQUFXO0lBQzVCLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRztJQUp0QixZQUNtQixpQkFBaUIsRUFBRSxXQUFXLEVBQzlCLGlCQUFpQixFQUFFLGlCQUFpQixFQUNwQyxXQUFXLEVBQUUsV0FBVyxFQUN4QixHQUFHLDhDQUFvQyxFQUN0RDtJQUVKOzs7Ozs7O09BT0c7SUFDVSxzQkFBc0IsQ0FDakMsUUFBUSxFQUFFLHNCQUFzQixFQUFFLEVBQ2xDLEtBQUssRUFBRSxZQUFZLEVBQ25CLGdCQUFnQixFQUFFLFdBQVcsQ0FBQyxNQUFNLEVBQUUscUJBQXFCLENBQUMsR0FDM0QsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVVmO0NBZ0ZGO0FBRUQsa0hBQWtIO0FBQ2xILE1BQU0sTUFBTSxxQkFBcUIsR0FBRyxPQUFPLEdBQUc7SUFDNUMsVUFBVSxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQ2pCLGNBQWMsRUFBRSxNQUFNLENBQUM7Q0FDeEIsQ0FBQyJ9

package/dest/events/event_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_service.d.ts","sourceRoot":"","sources":["../../src/events/event_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAG9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAExD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yEAAyE,CAAC;AACtH,OAAO,EAAE,iBAAiB,EAAE,MAAM,uDAAuD,CAAC;AAC1F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAE1E,qBAAa,YAAY;;IAErB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,GAAG;IAJtB,YACmB,iBAAiB,EAAE,WAAW,EAC9B,iBAAiB,EAAE,iBAAiB,EACpC,WAAW,EAAE,WAAW,EACxB,GAAG,8CAAoC,EACtD;IAEJ;;;;;;;OAOG;IACU,sBAAsB,CACjC,QAAQ,EAAE,sBAAsB,EAAE,EAClC,KAAK,EAAE,YAAY,EACnB,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAC3D,OAAO,CAAC,IAAI,CAAC,CAUf;CAgFF;AAED,kHAAkH;AAClH,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG;IAC5C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC"}