@aztec-labs/simulator 6.0.0-nightly.20260829

package/dest/public/avm_simulator_pool.js

@@ -0,0 +1,311 @@
+var _computedKey;
+import { AvmService } from '@aztec/bb-avm-sim';
+import { AbortError } from '@aztec-labs/foundation/error';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import { CdbIpcServer } from './cdb_ipc_server.js';
+/**
+ * The generated service flags errors caused by the death of the underlying process (rather than by the
+ * request itself) with `retry: true`. That distinction is interpreted here and goes no further: process
+ * lifecycle is invisible to the pool's callers.
+ */ function isProcessFailure(err) {
+    return err instanceof Error && err.retry === true;
+}
+/** Sleep that wakes early (without throwing) when the signal aborts; callers re-check the signal. */ async function abortableSleep(ms, signal) {
+    if (!signal) {
+        return sleep(ms);
+    }
+    let onAbort;
+    const aborted = new Promise((resolve)=>{
+        onAbort = resolve;
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+    });
+    try {
+        await Promise.race([
+            sleep(ms),
+            aborted
+        ]);
+    } finally{
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+// After a cancellation is requested, how long the C++ process gets to cancel cooperatively (SIGUSR1
+// checkpoint) before it is SIGKILLed. Killing is safe: the service respawns its process lazily, so the
+// pool slot recovers instead of being leaked to a wedged simulation.
+const CANCEL_KILL_GRACE_MS = 5_000;
+_computedKey = Symbol.asyncDispose;
+/**
+ * The public-execution AVM backend: a lazily-grown pool of bb-avm-sim services plus the CDB server that
+ * answers those processes' contract-data callbacks. Callers hold this as an {@link AvmSimulator}; the pool,
+ * the CDB server, its IPC path, and fork-id routing are all hidden behind that interface. Each `simulate`
+ * registers the call's contracts DB on the CDB server for the duration of the simulation (keyed by fork id
+ * so concurrent simulations on different forks don't collide) and unregisters it once the call returns.
+ *
+ * Process lifecycle is invisible to callers, exactly as when the simulator ran in-process: a simulation
+ * either produces a result, fails on its own merits, or runs until the caller's deadline aborts it.
+ * Environmental trouble is absorbed here — spawn failures retry indefinitely on a backoff ladder (bounded
+ * only by the caller's abort signal), and a simulation whose process dies is re-issued on the respawned
+ * process. The one deliberate exception: an input that kills the process twice is treated as a failing
+ * transaction, so a simulator-crashing tx gets evicted instead of burning a process per block forever.
+ */ export class AvmSimulatorPool {
+    options;
+    slots;
+    available;
+    waiters;
+    createdCount;
+    destroyed;
+    log;
+    maxSize;
+    cdbServer;
+    spawnRetryIntervalMs;
+    spawnProcess;
+    constructor(options){
+        this.options = options;
+        this.slots = [];
+        this.available = [];
+        this.waiters = [];
+        this.createdCount = 0;
+        this.destroyed = false;
+        this.log = createLogger('simulator:avm-pool');
+        this.maxSize = options.maxSize ?? parseInt(process.env.AVM_MAX_CONCURRENT_SIMULATIONS ?? '4', 10);
+        this.cdbServer = new CdbIpcServer();
+        this.spawnRetryIntervalMs = options.spawnRetryIntervalMs ?? 1_000;
+        this.spawnProcess = options.spawnProcess ?? ((spawnOptions)=>AvmSimulatorProcess.spawn(spawnOptions));
+    }
+    static async spawn(options) {
+        const pool = new AvmSimulatorPool(options);
+        // Always start one process up front so the first simulate() doesn't pay process spawn/connect cost.
+        // This is also where configuration errors (missing binary) surface, fast and fatally.
+        await pool.prewarm();
+        return pool;
+    }
+    async [_computedKey]() {
+        await this.destroy();
+    }
+    async simulate(inputBuffer, context, signal) {
+        // Register the fork's contracts DB so the C++ AVM's callbacks (which carry this fork id) route to it,
+        // and unregister once the simulation returns — registration is only needed while the call is running.
+        this.cdbServer.registerFork(context.forkId, context.contractsDB, context.timestamp);
+        try {
+            return await this.runOnPool((simulator)=>simulator.simulate(inputBuffer, signal), signal);
+        } finally{
+            this.cdbServer.unregisterFork(context.forkId);
+        }
+    }
+    async simulateWithHints(inputBuffer) {
+        // The hinted path makes no contract-data callbacks, so no CDB registration is needed.
+        return await this.runOnPool((simulator)=>simulator.simulateWithHints(inputBuffer));
+    }
+    /** Destroy all AVM services in the pool and close the CDB server. */ async destroy() {
+        this.destroyed = true;
+        for (const waiter of this.waiters.splice(0)){
+            waiter.reject(new Error('AVM simulator pool destroyed'));
+        }
+        await Promise.all(this.slots.map((slot)=>slot.destroy()));
+        this.slots = [];
+        this.available = [];
+        this.createdCount = 0;
+        await this.cdbServer.close();
+        this.log.info('AVM simulator pool destroyed');
+    }
+    /**
+   * Eagerly spawn up to `count` AVM processes (capped at maxSize) and leave them available, so the
+   * first simulate() doesn't pay process spawn/connect cost. Idempotent.
+   */ async prewarm(count = 1) {
+        const target = Math.min(count, this.maxSize);
+        const created = [];
+        while(this.createdCount < target){
+            created.push(await this.checkout());
+        }
+        // Hand the checked-out processes back to the pool so checkout() reuses them.
+        for (const simulator of created){
+            this.return(simulator);
+        }
+    }
+    /**
+   * Run a call on a pooled service. A call that fails because its process died is re-issued on the
+   * respawned process; a second death for the same input is attributed to the input and surfaces as an
+   * ordinary error (the pre-IPC equivalent — a native crash — took down the whole node, so a failed tx
+   * is strictly gentler). Non-process failures surface as-is: they are the simulation's own verdict.
+   */ async runOnPool(fn, signal) {
+        for(let attempt = 0;; attempt++){
+            const simulator = await this.checkout(signal);
+            try {
+                return await fn(simulator);
+            } catch (err) {
+                if (!isProcessFailure(err) || signal?.aborted) {
+                    throw err;
+                }
+                if (attempt > 0) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    throw new Error(`AVM simulator process died twice running this simulation; attributing the failure to the input: ${message}`, {
+                        cause: err
+                    });
+                }
+                this.log.warn(`AVM process died during simulation; re-issuing once on the respawned process`, {
+                    err
+                });
+            } finally{
+                this.return(simulator);
+            }
+        }
+    }
+    /** Check out an AVM service from the pool, blocking until one is free. Caller must return() it when done. */ async checkout(signal) {
+        if (this.destroyed) {
+            throw new Error('AVM simulator pool destroyed');
+        }
+        const idx = this.available.pop();
+        if (idx !== undefined) {
+            return this.slots[idx];
+        }
+        if (this.createdCount < this.maxSize) {
+            return await this.createSlot(signal);
+        }
+        return new Promise((resolve, reject)=>{
+            const waiter = {
+                resolve,
+                reject
+            };
+            if (signal) {
+                const onAbort = ()=>{
+                    const at = this.waiters.indexOf(waiter);
+                    if (at >= 0) {
+                        this.waiters.splice(at, 1);
+                        reject(new AbortError('AVM checkout aborted'));
+                    }
+                };
+                signal.addEventListener('abort', onAbort, {
+                    once: true
+                });
+                waiter.resolve = (simulator)=>{
+                    signal.removeEventListener('abort', onAbort);
+                    resolve(simulator);
+                };
+                waiter.reject = (err)=>{
+                    signal.removeEventListener('abort', onAbort);
+                    reject(err);
+                };
+            }
+            this.waiters.push(waiter);
+        });
+    }
+    /** Return an AVM service to the pool after use. */ return(simulator) {
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter.resolve(simulator);
+        } else {
+            const idx = this.slots.indexOf(simulator);
+            if (idx >= 0) {
+                this.available.push(idx);
+            }
+        }
+    }
+    async createSlot(signal) {
+        // Reserve the slot count synchronously, before the async spawn, so concurrent checkouts can't all
+        // observe `createdCount < maxSize` and overshoot the pool (the count is only bumped once control has
+        // yielded on the await). Roll back the reservation if the spawn is abandoned.
+        this.createdCount++;
+        try {
+            const simulator = await this.spawnUntilUp(signal);
+            this.slots.push(simulator);
+            this.log.debug(`Created AVM pool slot (${this.createdCount}/${this.maxSize})`);
+            return simulator;
+        } catch (err) {
+            this.createdCount--;
+            throw err;
+        }
+    }
+    /**
+   * Spawn a service, retrying environmental failures on a flat cadence indefinitely — the bound is
+   * the caller's own deadline (abort signal), matching the pre-IPC contract where a simulation either
+   * completed or was deadlined out. The cadence is deliberately fast and constant: an attempt is cheap,
+   * a slow one self-paces inside the backend's connect backstop, and backing off would cost a
+   * ~6s-slot sequencer whole blocks after the machine has already recovered. Configuration errors
+   * (missing binary, flagged non-retryable by the generated service) throw immediately; the boot-time
+   * prewarm is where those are meant to surface.
+   */ async spawnUntilUp(signal) {
+        for(let failures = 0;; failures++){
+            if (this.destroyed) {
+                throw new Error('AVM simulator pool destroyed');
+            }
+            if (signal?.aborted) {
+                throw new AbortError('AVM process spawn aborted');
+            }
+            try {
+                return await this.spawnProcess({
+                    binaryPath: this.options.avmBinaryPath,
+                    wsdbIpcPath: this.options.wsdbIpcPath,
+                    cdbIpcPath: this.cdbServer.ipcPath,
+                    logger: this.options.logger
+                });
+            } catch (err) {
+                if (!isProcessFailure(err)) {
+                    throw err;
+                }
+                this.log.warn(`Failed to spawn AVM process (attempt ${failures + 1}); retrying in ${this.spawnRetryIntervalMs}ms`, {
+                    err
+                });
+                await abortableSleep(this.spawnRetryIntervalMs, signal);
+            }
+        }
+    }
+}
+class AvmSimulatorProcess {
+    service;
+    constructor(service){
+        this.service = service;
+    }
+    static async spawn(options) {
+        const service = await AvmService.spawn({
+            binaryPath: options.binaryPath,
+            transport: 'uds',
+            logger: options.logger,
+            extraArgs: [
+                '--wsdb',
+                options.wsdbIpcPath,
+                '--cdb',
+                options.cdbIpcPath
+            ],
+            // Each simulation is self-contained (state comes from the WSDB/CDB servers, routed by fork id),
+            // so a fresh process can safely serve the next call after a death.
+            respawn: true
+        });
+        return new AvmSimulatorProcess(service);
+    }
+    async simulate(inputBuffer, signal) {
+        let killTimer;
+        // Cooperative cancellation first: SIGUSR1 makes the C++ process stop at its next cancellation
+        // checkpoint. If it doesn't respond within the grace (wedged in a slow op), SIGKILL it — the
+        // service respawns lazily, so this reclaims the pool slot rather than leaking it.
+        const onAbort = ()=>{
+            this.service.sendProcessSignal('SIGUSR1');
+            killTimer = setTimeout(()=>this.service.sendProcessSignal('SIGKILL'), CANCEL_KILL_GRACE_MS);
+        };
+        if (signal?.aborted) {
+            onAbort();
+        }
+        signal?.addEventListener('abort', onAbort, {
+            once: true
+        });
+        try {
+            return (await this.service.simulate({
+                inputs: inputBuffer
+            })).result;
+        } finally{
+            signal?.removeEventListener('abort', onAbort);
+            if (killTimer !== undefined) {
+                clearTimeout(killTimer);
+            }
+        }
+    }
+    async simulateWithHints(inputBuffer) {
+        return (await this.service.simulateWithHints({
+            inputs: inputBuffer
+        })).result;
+    }
+    async destroy() {
+        await this.service.destroy();
+    }
+}

package/dest/public/cdb_ipc_server.d.ts

@@ -0,0 +1,40 @@
+/**
+ * UDS server for AVM CDB requests.
+ *
+ * Transport (socket, framing, per-connection response ordering) is handled by the shared
+ * `UdsIpcServer` from `@aztec/ipc-runtime`; message dispatch comes from the generated CDB
+ * server. This class only implements the generated handler interface and routes requests to
+ * PublicContractsDB instances by fork ID.
+ */
+import { type CdbAddContracts, type CdbAddContractsResponse, type CdbCommitCheckpoint, type CdbCommitCheckpointResponse, type CdbCreateCheckpoint, type CdbCreateCheckpointResponse, type CdbGetBytecodeCommitment, type CdbGetBytecodeCommitmentResponse, type CdbGetContractClass, type CdbGetContractClassResponse, type CdbGetContractInstance, type CdbGetContractInstanceResponse, type CdbGetDebugFunctionName, type CdbGetDebugFunctionNameResponse, type Handler as CdbHandler, type CdbRevertCheckpoint, type CdbRevertCheckpointResponse } from '@aztec/cdb';
+import { type ContractInstanceWithAddress } from '@aztec-labs/stdlib/contract';
+import type { PublicContractsDB } from './public_db_sources.js';
+/** Serializes contract instances to the AVM CDB wire shape. */
+export declare function serializeContractInstance(instance: ContractInstanceWithAddress): Record<string, unknown>;
+/** Routes AVM CDB IPC requests to registered PublicContractsDB forks. */
+export declare class CdbIpcServer implements CdbHandler {
+    readonly ipcPath: string;
+    private server;
+    private log;
+    /** Maps WSDB fork IDs to contracts DB/timestamp pairs for concurrent simulations. */
+    private forks;
+    constructor();
+    /** Register a PublicContractsDB for a given WSDB fork ID. */
+    registerFork(forkId: number, contractsDB: PublicContractsDB, timestamp: bigint): void;
+    /** Unregister a fork's contracts DB (call after simulation completes). */
+    unregisterFork(forkId: number): void;
+    /** Close the server and all active connections. */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    /** Look up the contracts DB for a given fork ID, throwing if not registered. */
+    private getFork;
+    getContractInstance(command: CdbGetContractInstance): Promise<CdbGetContractInstanceResponse>;
+    getContractClass(command: CdbGetContractClass): Promise<CdbGetContractClassResponse>;
+    getBytecodeCommitment(command: CdbGetBytecodeCommitment): Promise<CdbGetBytecodeCommitmentResponse>;
+    getDebugFunctionName(command: CdbGetDebugFunctionName): Promise<CdbGetDebugFunctionNameResponse>;
+    addContracts(command: CdbAddContracts): Promise<CdbAddContractsResponse>;
+    createCheckpoint(command: CdbCreateCheckpoint): Promise<CdbCreateCheckpointResponse>;
+    commitCheckpoint(command: CdbCommitCheckpoint): Promise<CdbCommitCheckpointResponse>;
+    revertCheckpoint(command: CdbRevertCheckpoint): Promise<CdbRevertCheckpointResponse>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2RiX2lwY19zZXJ2ZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMvY2RiX2lwY19zZXJ2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUNILE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFDcEIsS0FBSyx1QkFBdUIsRUFDNUIsS0FBSyxtQkFBbUIsRUFDeEIsS0FBSywyQkFBMkIsRUFDaEMsS0FBSyxtQkFBbUIsRUFDeEIsS0FBSywyQkFBMkIsRUFDaEMsS0FBSyx3QkFBd0IsRUFDN0IsS0FBSyxnQ0FBZ0MsRUFDckMsS0FBSyxtQkFBbUIsRUFDeEIsS0FBSywyQkFBMkIsRUFDaEMsS0FBSyxzQkFBc0IsRUFDM0IsS0FBSyw4QkFBOEIsRUFDbkMsS0FBSyx1QkFBdUIsRUFDNUIsS0FBSywrQkFBK0IsRUFDcEMsS0FBSyxPQUFPLElBQUksVUFBVSxFQUMxQixLQUFLLG1CQUFtQixFQUN4QixLQUFLLDJCQUEyQixFQUVqQyxNQUFNLFlBQVksQ0FBQztBQU9wQixPQUFPLEVBQTBCLEtBQUssMkJBQTJCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQU12RyxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBV2hFLCtEQUErRDtBQUMvRCx3QkFBZ0IseUJBQXlCLENBQUMsUUFBUSxFQUFFLDJCQUEyQixHQUFHLE1BQU0sQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBb0J4RztBQWlCRCx5RUFBeUU7QUFDekUscUJBQWEsWUFBYSxZQUFXLFVBQVU7SUFDN0MsU0FBZ0IsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQyxPQUFPLENBQUMsTUFBTSxDQUF3QjtJQUN0QyxPQUFPLENBQUMsR0FBRyxDQUFTO0lBQ3BCLHFGQUFxRjtJQUNyRixPQUFPLENBQUMsS0FBSyxDQUFtRTtJQUVoRixjQVVDO0lBRUQsNkRBQTZEO0lBQzdELFlBQVksQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxpQkFBaUIsRUFBRSxTQUFTLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FFcEY7SUFFRCwwRUFBMEU7SUFDMUUsY0FBYyxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUVuQztJQUVELG1EQUFtRDtJQUM3QyxLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUczQjtJQUVLLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFM0M7SUFFRCxnRkFBZ0Y7SUFDaEYsT0FBTyxDQUFDLE9BQU87SUFXVCxtQkFBbUIsQ0FBQyxPQUFPLEVBQUUsc0JBQXNCLEdBQUcsT0FBTyxDQUFDLDhCQUE4QixDQUFDLENBS2xHO0lBRUssZ0JBQWdCLENBQUMsT0FBTyxFQUFFLG1CQUFtQixHQUFHLE9BQU8sQ0FBQywyQkFBMkIsQ0FBQyxDQUt6RjtJQUVLLHFCQUFxQixDQUFDLE9BQU8sRUFBRSx3QkFBd0IsR0FBRyxPQUFPLENBQUMsZ0NBQWdDLENBQUMsQ0FLeEc7SUFFSyxvQkFBb0IsQ0FBQyxPQUFPLEVBQUUsdUJBQXVCLEdBQUcsT0FBTyxDQUFDLCtCQUErQixDQUFDLENBT3JHO0lBRUQsWUFBWSxDQUFDLE9BQU8sRUFBRSxlQUFlLEdBQUcsT0FBTyxDQUFDLHVCQUF1QixDQUFDLENBT3ZFO0lBRUQsZ0JBQWdCLENBQUMsT0FBTyxFQUFFLG1CQUFtQixHQUFHLE9BQU8sQ0FBQywyQkFBMkIsQ0FBQyxDQUluRjtJQUVELGdCQUFnQixDQUFDLE9BQU8sRUFBRSxtQkFBbUIsR0FBRyxPQUFPLENBQUMsMkJBQTJCLENBQUMsQ0FJbkY7SUFFRCxnQkFBZ0IsQ0FBQyxPQUFPLEVBQUUsbUJBQW1CLEdBQUcsT0FBTyxDQUFDLDJCQUEyQixDQUFDLENBSW5GO0NBQ0YifQ==

package/dest/public/cdb_ipc_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdb_ipc_server.d.ts","sourceRoot":"","sources":["../../src/public/cdb_ipc_server.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,gCAAgC,EACrC,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAC3B,KAAK,8BAA8B,EACnC,KAAK,uBAAuB,EAC5B,KAAK,+BAA+B,EACpC,KAAK,OAAO,IAAI,UAAU,EAC1B,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAEjC,MAAM,YAAY,CAAC;AAOpB,OAAO,EAA0B,KAAK,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAMvG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAWhE,+DAA+D;AAC/D,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,2BAA2B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBxG;AAiBD,yEAAyE;AACzE,qBAAa,YAAa,YAAW,UAAU;IAC7C,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,GAAG,CAAS;IACpB,qFAAqF;IACrF,OAAO,CAAC,KAAK,CAAmE;IAEhF,cAUC;IAED,6DAA6D;IAC7D,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAEpF;IAED,0EAA0E;IAC1E,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEnC;IAED,mDAAmD;IAC7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAG3B;IAEK,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3C;IAED,gFAAgF;IAChF,OAAO,CAAC,OAAO;IAWT,mBAAmB,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAKlG;IAEK,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAKzF;IAEK,qBAAqB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,gCAAgC,CAAC,CAKxG;IAEK,oBAAoB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAOrG;IAED,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAOvE;IAED,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAInF;IAED,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAInF;IAED,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAInF;CACF"}

package/dest/public/cdb_ipc_server.js

@@ -0,0 +1,153 @@
+/**
+ * UDS server for AVM CDB requests.
+ *
+ * Transport (socket, framing, per-connection response ordering) is handled by the shared
+ * `UdsIpcServer` from `@aztec/ipc-runtime`; message dispatch comes from the generated CDB
+ * server. This class only implements the generated handler interface and routes requests to
+ * PublicContractsDB instances by fork ID.
+ */ var _computedKey;
+import { handleRequest } from '@aztec/cdb';
+import { UdsIpcServer } from '@aztec/ipc-runtime';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { FunctionSelector } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { ContractDeploymentData } from '@aztec-labs/stdlib/contract';
+import { Decoder, Encoder } from 'msgpackr';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { threadId } from 'node:worker_threads';
+const encoder = new Encoder({
+    useRecords: false
+});
+const decoder = new Decoder({
+    useRecords: false
+});
+let instanceCounter = 0;
+function toFieldBuffer(field) {
+    return field.toBuffer();
+}
+/** Serializes contract instances to the AVM CDB wire shape. */ export function serializeContractInstance(instance) {
+    return {
+        salt: toFieldBuffer(instance.salt),
+        deployer: toFieldBuffer(instance.deployer),
+        currentContractClassId: toFieldBuffer(instance.currentContractClassId),
+        originalContractClassId: toFieldBuffer(instance.originalContractClassId),
+        initializationHash: toFieldBuffer(instance.initializationHash),
+        immutablesHash: toFieldBuffer(instance.immutablesHash),
+        publicKeys: {
+            npkMHash: toFieldBuffer(instance.publicKeys.npkMHash),
+            ivpkM: {
+                x: toFieldBuffer(instance.publicKeys.ivpkM.x),
+                y: toFieldBuffer(instance.publicKeys.ivpkM.y)
+            },
+            ovpkMHash: toFieldBuffer(instance.publicKeys.ovpkMHash),
+            tpkMHash: toFieldBuffer(instance.publicKeys.tpkMHash),
+            mspkMHash: toFieldBuffer(instance.publicKeys.mspkMHash),
+            fbpkMHash: toFieldBuffer(instance.publicKeys.fbpkMHash)
+        }
+    };
+}
+/** Serializes contract classes to the AVM CDB wire shape. */ function serializeContractClass(contractClass) {
+    return {
+        id: toFieldBuffer(contractClass.id),
+        artifactHash: toFieldBuffer(contractClass.artifactHash),
+        privateFunctionsRoot: toFieldBuffer(contractClass.privateFunctionsRoot),
+        packedBytecode: contractClass.packedBytecode
+    };
+}
+_computedKey = Symbol.asyncDispose;
+/** Routes AVM CDB IPC requests to registered PublicContractsDB forks. */ export class CdbIpcServer {
+    ipcPath;
+    server;
+    log;
+    /** Maps WSDB fork IDs to contracts DB/timestamp pairs for concurrent simulations. */ forks = new Map();
+    constructor(){
+        this.log = createLogger('cdb-ipc-server');
+        this.ipcPath = path.join(os.tmpdir(), `cdb-ts-${process.pid}-${threadId}-${instanceCounter++}.sock`);
+        // Listen asynchronously; the C++ AVM retries connecting until the socket is up.
+        this.server = UdsIpcServer.listen(this.ipcPath, (_clientId, request)=>handleRequest(this, request));
+        this.server.then(()=>this.log.debug(`CDB IPC server listening on ${this.ipcPath}`), (err)=>this.log.error(`CDB IPC server failed to listen on ${this.ipcPath}`, {
+                err
+            }));
+    }
+    /** Register a PublicContractsDB for a given WSDB fork ID. */ registerFork(forkId, contractsDB, timestamp) {
+        this.forks.set(forkId, {
+            db: contractsDB,
+            timestamp
+        });
+    }
+    /** Unregister a fork's contracts DB (call after simulation completes). */ unregisterFork(forkId) {
+        this.forks.delete(forkId);
+    }
+    /** Close the server and all active connections. */ async close() {
+        const server = await this.server.catch(()=>undefined);
+        await server?.close();
+    }
+    async [_computedKey]() {
+        await this.close();
+    }
+    /** Look up the contracts DB for a given fork ID, throwing if not registered. */ getFork(forkId) {
+        const fork = this.forks.get(forkId);
+        if (!fork) {
+            const registered = Array.from(this.forks.keys()).sort((a, b)=>a - b);
+            throw new Error(`CDB server: no contracts DB registered for forkId ${forkId} (registered=[${registered.join(',')}])`);
+        }
+        return fork;
+    }
+    async getContractInstance(command) {
+        const { db, timestamp } = this.getFork(command.forkId);
+        const address = AztecAddress.fromBuffer(Buffer.from(command.address));
+        const instance = await db.getContractInstance(address, timestamp);
+        return {
+            instance: instance ? encoder.encode(serializeContractInstance(instance)) : null
+        };
+    }
+    async getContractClass(command) {
+        const { db } = this.getFork(command.forkId);
+        const classId = Fr.fromBuffer(Buffer.from(command.classId));
+        const contractClass = await db.getContractClass(classId);
+        return {
+            contractClass: contractClass ? encoder.encode(serializeContractClass(contractClass)) : null
+        };
+    }
+    async getBytecodeCommitment(command) {
+        const { db } = this.getFork(command.forkId);
+        const classId = Fr.fromBuffer(Buffer.from(command.classId));
+        const commitment = await db.getBytecodeCommitment(classId);
+        return {
+            commitment: commitment ? toFieldBuffer(commitment) : null
+        };
+    }
+    async getDebugFunctionName(command) {
+        const { db } = this.getFork(command.forkId);
+        const address = AztecAddress.fromBuffer(Buffer.from(command.address));
+        const selectorField = Fr.fromBuffer(Buffer.from(command.selector));
+        const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
+        const name = selector ? await db.getDebugFunctionName(address, selector) : undefined;
+        return {
+            name: name ?? null
+        };
+    }
+    addContracts(command) {
+        const { db } = this.getFork(command.forkId);
+        const contractDeploymentData = ContractDeploymentData.fromPlainObject(decoder.decode(command.contractDeploymentData));
+        db.addContractsFromLogs(contractDeploymentData);
+        return Promise.resolve({});
+    }
+    createCheckpoint(command) {
+        const { db } = this.getFork(command.forkId);
+        db.createCheckpoint();
+        return Promise.resolve({});
+    }
+    commitCheckpoint(command) {
+        const { db } = this.getFork(command.forkId);
+        db.commitCheckpoint();
+        return Promise.resolve({});
+    }
+    revertCheckpoint(command) {
+        const { db } = this.getFork(command.forkId);
+        db.revertCheckpoint();
+        return Promise.resolve({});
+    }
+}

package/dest/public/contracts_db_checkpoint.d.ts

@@ -0,0 +1,16 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec-labs/stdlib/contract';
+export declare class ContractsDbCheckpoint {
+    private instances;
+    private classes;
+    private bytecodeCommitments;
+    addInstance(address: AztecAddress, instance: ContractInstanceWithAddress): void;
+    addClass(classId: Fr, contractClass: ContractClassPublic): void;
+    addBytecodeCommitment(classId: Fr, commitment: Fr): void;
+    getInstance(address: AztecAddress): ContractInstanceWithAddress | undefined;
+    getClass(classId: Fr): ContractClassPublic | undefined;
+    getBytecodeCommitment(classId: Fr): Fr | undefined;
+    fork(): ContractsDbCheckpoint;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RzX2RiX2NoZWNrcG9pbnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMvY29udHJhY3RzX2RiX2NoZWNrcG9pbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDOUQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDckUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVwRyxxQkFBYSxxQkFBcUI7SUFDaEMsT0FBTyxDQUFDLFNBQVMsQ0FBdUQ7SUFDeEUsT0FBTyxDQUFDLE9BQU8sQ0FBK0M7SUFDOUQsT0FBTyxDQUFDLG1CQUFtQixDQUE4QjtJQUVsRCxXQUFXLENBQUMsT0FBTyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsMkJBQTJCLEdBQUcsSUFBSSxDQUVyRjtJQUVNLFFBQVEsQ0FBQyxPQUFPLEVBQUUsRUFBRSxFQUFFLGFBQWEsRUFBRSxtQkFBbUIsR0FBRyxJQUFJLENBRXJFO0lBRU0scUJBQXFCLENBQUMsT0FBTyxFQUFFLEVBQUUsRUFBRSxVQUFVLEVBQUUsRUFBRSxHQUFHLElBQUksQ0FFOUQ7SUFFTSxXQUFXLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRywyQkFBMkIsR0FBRyxTQUFTLENBRWpGO0lBRU0sUUFBUSxDQUFDLE9BQU8sRUFBRSxFQUFFLEdBQUcsbUJBQW1CLEdBQUcsU0FBUyxDQUU1RDtJQUVNLHFCQUFxQixDQUFDLE9BQU8sRUFBRSxFQUFFLEdBQUcsRUFBRSxHQUFHLFNBQVMsQ0FFeEQ7SUFFTSxJQUFJLElBQUkscUJBQXFCLENBTW5DO0NBQ0YifQ==

package/dest/public/contracts_db_checkpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts_db_checkpoint.d.ts","sourceRoot":"","sources":["../../src/public/contracts_db_checkpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAEpG,qBAAa,qBAAqB;IAChC,OAAO,CAAC,SAAS,CAAuD;IACxE,OAAO,CAAC,OAAO,CAA+C;IAC9D,OAAO,CAAC,mBAAmB,CAA8B;IAElD,WAAW,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,2BAA2B,GAAG,IAAI,CAErF;IAEM,QAAQ,CAAC,OAAO,EAAE,EAAE,EAAE,aAAa,EAAE,mBAAmB,GAAG,IAAI,CAErE;IAEM,qBAAqB,CAAC,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,GAAG,IAAI,CAE9D;IAEM,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,2BAA2B,GAAG,SAAS,CAEjF;IAEM,QAAQ,CAAC,OAAO,EAAE,EAAE,GAAG,mBAAmB,GAAG,SAAS,CAE5D;IAEM,qBAAqB,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,GAAG,SAAS,CAExD;IAEM,IAAI,IAAI,qBAAqB,CAMnC;CACF"}

package/dest/public/contracts_db_checkpoint.js

@@ -0,0 +1,30 @@
+export class ContractsDbCheckpoint {
+    instances = new Map();
+    classes = new Map();
+    bytecodeCommitments = new Map();
+    addInstance(address, instance) {
+        this.instances.set(address.toString(), instance);
+    }
+    addClass(classId, contractClass) {
+        this.classes.set(classId.toString(), contractClass);
+    }
+    addBytecodeCommitment(classId, commitment) {
+        this.bytecodeCommitments.set(classId.toString(), commitment);
+    }
+    getInstance(address) {
+        return this.instances.get(address.toString());
+    }
+    getClass(classId) {
+        return this.classes.get(classId.toString());
+    }
+    getBytecodeCommitment(classId) {
+        return this.bytecodeCommitments.get(classId.toString());
+    }
+    fork() {
+        const copy = new ContractsDbCheckpoint();
+        this.instances.forEach((value, key)=>copy.instances.set(key, value));
+        this.classes.forEach((value, key)=>copy.classes.set(key, value));
+        this.bytecodeCommitments.forEach((value, key)=>copy.bytecodeCommitments.set(key, value));
+        return copy;
+    }
+}

package/dest/public/db_interfaces.d.ts

@@ -0,0 +1,68 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { FunctionSelector } from '@aztec-labs/stdlib/abi';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec-labs/stdlib/contract';
+import type { UInt64 } from '@aztec-labs/stdlib/types';
+/**
+ * Database interface for providing access to public state.
+ */
+export interface PublicStateDBInterface {
+    /**
+     * Reads a value from public storage, returning zero if none.
+     * @param contract - Owner of the storage.
+     * @param slot - Slot to read in the contract storage.
+     * @returns The current value in the storage slot.
+     */
+    storageRead(contract: AztecAddress, slot: Fr): Promise<Fr>;
+    /**
+     * Records a write to public storage.
+     * @param contract - Owner of the storage.
+     * @param slot - Slot to read in the contract storage.
+     * @param newValue - The new value to store.
+     */
+    storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
+}
+/**
+ * Database interface for providing access to public contract data.
+ */
+export interface PublicContractsDBInterface {
+    /**
+     * Returns a contract instance given its address and the given timestamp, or undefined if not exists.
+     * @param address - Address of the contract.
+     * @param timestamp - Timestamp to get the contract instance at. Contract updates might change the instance.
+     * @returns The contract instance or undefined if not found.
+     */
+    getContractInstance(address: AztecAddress, timestamp: UInt64): Promise<ContractInstanceWithAddress | undefined>;
+    /**
+     * Returns a publicly deployed contract class.
+     * @param contractClassId - ID of the contract class.
+     * @returns The contract class or undefined if not found
+     */
+    getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined>;
+    /**
+     * Returns the commitment to the bytecode of a contract class.
+     * @param contractClassId - ID of the contract class.
+     * @returns The commitment to the bytecode or undefined if not found.
+     */
+    getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined>;
+    /**
+     * Returns the function name of a contract's function given its selector.
+     * @param contractAddress - Address of the contract.
+     * @param selector - Selector of the function.
+     * @returns The name of the function or undefined if not found.
+     */
+    getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+    /**
+     * Creates a checkpoint of the current contract state.
+     */
+    createCheckpoint(): void;
+    /**
+     * Commits the current checkpoint, merging its state with the parent.
+     */
+    commitCheckpoint(): void;
+    /**
+     * Reverts the current checkpoint, discarding its state.
+     */
+    revertCheckpoint(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGJfaW50ZXJmYWNlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1YmxpYy9kYl9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzlELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDL0QsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDckUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNwRyxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUV2RDs7R0FFRztBQUNILE1BQU0sV0FBVyxzQkFBc0I7SUFDckM7Ozs7O09BS0c7SUFDSCxXQUFXLENBQUMsUUFBUSxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUUzRDs7Ozs7T0FLRztJQUNILFlBQVksQ0FBQyxRQUFRLEVBQUUsWUFBWSxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsUUFBUSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7Q0FDN0U7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVywwQkFBMEI7SUFDekM7Ozs7O09BS0c7SUFDSCxtQkFBbUIsQ0FBQyxPQUFPLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLDJCQUEyQixHQUFHLFNBQVMsQ0FBQyxDQUFDO0lBRWhIOzs7O09BSUc7SUFDSCxnQkFBZ0IsQ0FBQyxlQUFlLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxtQkFBbUIsR0FBRyxTQUFTLENBQUMsQ0FBQztJQUVoRjs7OztPQUlHO0lBQ0gscUJBQXFCLENBQUMsZUFBZSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsRUFBRSxHQUFHLFNBQVMsQ0FBQyxDQUFDO0lBRXBFOzs7OztPQUtHO0lBQ0gsb0JBQW9CLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FBQztJQUU3Rzs7T0FFRztJQUNILGdCQUFnQixJQUFJLElBQUksQ0FBQztJQUV6Qjs7T0FFRztJQUNILGdCQUFnQixJQUFJLElBQUksQ0FBQztJQUV6Qjs7T0FFRztJQUNILGdCQUFnQixJQUFJLElBQUksQ0FBQztDQUMxQiJ9

package/dest/public/db_interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db_interfaces.d.ts","sourceRoot":"","sources":["../../src/public/db_interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AACpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC;IAE3D;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7E;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,mBAAmB,CAAC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC,CAAC;IAEhH;;;;OAIG;IACH,gBAAgB,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAAC;IAEhF;;;;OAIG;IACH,qBAAqB,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IAEpE;;;;;OAKG;IACH,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAE7G;;OAEG;IACH,gBAAgB,IAAI,IAAI,CAAC;IAEzB;;OAEG;IACH,gBAAgB,IAAI,IAAI,CAAC;IAEzB;;OAEG;IACH,gBAAgB,IAAI,IAAI,CAAC;CAC1B"}

package/dest/public/db_interfaces.js

@@ -0,0 +1,3 @@
+/**
+ * Database interface for providing access to public contract data.
+ */ export { };