@aztec/pxe 0.0.1-commit.4eabbdb → 0.0.1-commit.5358163d3

package/src/private_kernel/hints/test_utils.ts

@@ -0,0 +1,325 @@
+import {
+  MAX_KEY_VALIDATION_REQUESTS_PER_CALL,
+  MAX_KEY_VALIDATION_REQUESTS_PER_TX,
+  MAX_NOTE_HASHES_PER_CALL,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+  MAX_NULLIFIERS_PER_CALL,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+  MAX_PRIVATE_LOGS_PER_CALL,
+  MAX_PRIVATE_LOGS_PER_TX,
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import type { Serializable } from '@aztec/foundation/serialize';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  ClaimedLengthArray,
+  KeyValidationRequest,
+  KeyValidationRequestAndSeparator,
+  NoteHash,
+  Nullifier,
+  PrivateCircuitPublicInputs,
+  PrivateKernelCircuitPublicInputs,
+  type PrivateKernelSimulateOutput,
+  ReadRequest,
+  ScopedKeyValidationRequestAndSeparator,
+  ScopedNoteHash,
+  ScopedNullifier,
+  ScopedReadRequest,
+} from '@aztec/stdlib/kernel';
+import { PrivateLogData, ScopedPrivateLogData } from '@aztec/stdlib/kernel';
+import { PrivateLog } from '@aztec/stdlib/logs';
+import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
+
+const DEFAULT_CONTRACT_ADDRESS = AztecAddress.fromBigInt(987654n);
+
+/**
+ * Builds a ClaimedLengthArray from a list of items, padding to the required size.
+ */
+function makeClaimed<T extends Serializable, N extends number>(items: T[], emptyFactory: { empty(): T }, maxSize: N) {
+  const padded = makeTuple(maxSize, i => items[i] ?? emptyFactory.empty());
+  return new ClaimedLengthArray<T, typeof maxSize>(padded, items.length);
+}
+
+/** Builder for PrivateKernelCircuitPublicInputs with fluent API for adding side effects. */
+export class PrivateKernelCircuitPublicInputsBuilder {
+  private noteHashes: ScopedNoteHash[] = [];
+  private nullifiers: ScopedNullifier[] = [];
+  private noteHashReadRequests: ScopedReadRequest[] = [];
+  private nullifierReadRequests: ScopedReadRequest[] = [];
+  private keyValidationRequests: ScopedKeyValidationRequestAndSeparator[] = [];
+  private privateLogs: ScopedPrivateLogData[] = [];
+  private nextCounter: number;
+
+  constructor(
+    private contractAddress: AztecAddress = DEFAULT_CONTRACT_ADDRESS,
+    startCounter = 1,
+  ) {
+    this.nextCounter = startCounter;
+  }
+
+  private getCounter(sideEffectCounter?: number): number {
+    if (sideEffectCounter !== undefined) {
+      this.nextCounter = sideEffectCounter + 1;
+      return sideEffectCounter;
+    }
+    return this.nextCounter++;
+  }
+
+  /** Adds a note hash to the accumulated data. Defaults are generated randomly. */
+  addNoteHash(opts?: { value?: Fr; counter?: number; contractAddress?: AztecAddress }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    const addr = opts?.contractAddress ?? this.contractAddress;
+    this.noteHashes.push(new NoteHash(value, counter).scope(addr));
+    return this;
+  }
+
+  /** Adds a nullifier to the accumulated data. Defaults are generated randomly. */
+  addNullifier(opts?: { value?: Fr; noteHash?: Fr; counter?: number; contractAddress?: AztecAddress }): this {
+    const value = opts?.value ?? Fr.random();
+    const noteHash = opts?.noteHash ?? Fr.ZERO;
+    const counter = this.getCounter(opts?.counter);
+    const addr = opts?.contractAddress ?? this.contractAddress;
+    this.nullifiers.push(new Nullifier(value, noteHash, counter).scope(addr));
+    return this;
+  }
+
+  /** Adds a pending note hash read request (non-empty contract address, can match a pending note hash). */
+  addPendingNoteHashReadRequest(opts?: { value?: Fr; counter?: number; contractAddress?: AztecAddress }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    const addr = opts?.contractAddress ?? this.contractAddress;
+    this.noteHashReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), addr));
+    return this;
+  }
+
+  /** Adds a settled note hash read request (empty contract address, resolved against the note hash tree). */
+  addSettledNoteHashReadRequest(opts?: { value?: Fr; counter?: number }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    this.noteHashReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), AztecAddress.ZERO));
+    return this;
+  }
+
+  /** Adds a pending nullifier read request (non-empty contract address, can match a pending nullifier). */
+  addPendingNullifierReadRequest(opts?: { value?: Fr; counter?: number; contractAddress?: AztecAddress }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    const addr = opts?.contractAddress ?? this.contractAddress;
+    this.nullifierReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), addr));
+    return this;
+  }
+
+  /** Adds a settled nullifier read request (empty contract address, resolved against the nullifier tree). */
+  addSettledNullifierReadRequest(opts?: { value?: Fr; counter?: number }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    this.nullifierReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), AztecAddress.ZERO));
+    return this;
+  }
+
+  /** Adds a key validation request to validation requests. */
+  addKeyValidationRequest(opts?: { contractAddress?: AztecAddress }): this {
+    const addr = opts?.contractAddress ?? this.contractAddress;
+    this.keyValidationRequests.push(
+      new ScopedKeyValidationRequestAndSeparator(
+        new KeyValidationRequestAndSeparator(
+          new KeyValidationRequest(new Point(Fr.random(), Fr.random(), false), Fr.random()),
+          Fr.random(),
+        ),
+        addr,
+      ),
+    );
+    return this;
+  }
+
+  /** Adds a private log to the accumulated data. Defaults are generated randomly. */
+  addPrivateLog(opts?: { noteHashCounter?: number; counter?: number; contractAddress?: AztecAddress }): this {
+    const noteHashCounter = opts?.noteHashCounter ?? 0;
+    const counter = this.getCounter(opts?.counter);
+    const addr = opts?.contractAddress ?? this.contractAddress;
+    this.privateLogs.push(
+      new ScopedPrivateLogData(new PrivateLogData(PrivateLog.empty(), noteHashCounter, counter), addr),
+    );
+    return this;
+  }
+
+  /** Builds the PrivateKernelCircuitPublicInputs with all added side effects. */
+  build(): PrivateKernelCircuitPublicInputs {
+    const publicInputs = PrivateKernelCircuitPublicInputs.empty();
+    publicInputs.end.noteHashes = makeClaimed(this.noteHashes, ScopedNoteHash, MAX_NOTE_HASHES_PER_TX);
+    publicInputs.end.nullifiers = makeClaimed(this.nullifiers, ScopedNullifier, MAX_NULLIFIERS_PER_TX);
+    publicInputs.end.privateLogs = makeClaimed(this.privateLogs, ScopedPrivateLogData, MAX_PRIVATE_LOGS_PER_TX);
+    publicInputs.validationRequests.noteHashReadRequests = makeClaimed(
+      this.noteHashReadRequests,
+      ScopedReadRequest,
+      MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+    );
+    publicInputs.validationRequests.nullifierReadRequests = makeClaimed(
+      this.nullifierReadRequests,
+      ScopedReadRequest,
+      MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+    );
+    publicInputs.validationRequests.scopedKeyValidationRequestsAndSeparators = makeClaimed(
+      this.keyValidationRequests,
+      ScopedKeyValidationRequestAndSeparator,
+      MAX_KEY_VALIDATION_REQUESTS_PER_TX,
+    );
+    return publicInputs;
+  }
+}
+
+/** Builder for PrivateCircuitPublicInputs (call-level) with fluent API for adding side effects. */
+export class PrivateCircuitPublicInputsBuilder {
+  private noteHashes: NoteHash[] = [];
+  private nullifiers: Nullifier[] = [];
+  private noteHashReadRequests: ScopedReadRequest[] = [];
+  private nullifierReadRequests: ScopedReadRequest[] = [];
+  private keyValidationRequests: KeyValidationRequestAndSeparator[] = [];
+  private privateLogs: PrivateLogData[] = [];
+  private nextCounter: number;
+
+  constructor(
+    private contractAddress: AztecAddress = DEFAULT_CONTRACT_ADDRESS,
+    startCounter = 1,
+  ) {
+    this.nextCounter = startCounter;
+  }
+
+  private getCounter(sideEffectCounter?: number): number {
+    if (sideEffectCounter !== undefined) {
+      this.nextCounter = sideEffectCounter + 1;
+      return sideEffectCounter;
+    }
+    return this.nextCounter++;
+  }
+
+  /** Adds a note hash. Defaults are generated randomly. */
+  addNoteHash(opts?: { value?: Fr; counter?: number }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    this.noteHashes.push(new NoteHash(value, counter));
+    return this;
+  }
+
+  /** Adds a nullifier. Defaults are generated randomly. */
+  addNullifier(opts?: { value?: Fr; noteHash?: Fr; counter?: number }): this {
+    const value = opts?.value ?? Fr.random();
+    const noteHash = opts?.noteHash ?? Fr.ZERO;
+    const counter = this.getCounter(opts?.counter);
+    this.nullifiers.push(new Nullifier(value, noteHash, counter));
+    return this;
+  }
+
+  /** Adds a pending note hash read request (non-empty contract address, can match a pending note hash). */
+  addPendingNoteHashReadRequest(opts?: { value?: Fr; counter?: number }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    this.noteHashReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), this.contractAddress));
+    return this;
+  }
+
+  /** Adds a settled note hash read request (empty contract address, resolved against the note hash tree). */
+  addSettledNoteHashReadRequest(opts?: { value?: Fr; counter?: number }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    this.noteHashReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), AztecAddress.ZERO));
+    return this;
+  }
+
+  /** Adds a pending nullifier read request (non-empty contract address, can match a pending nullifier). */
+  addPendingNullifierReadRequest(opts?: { value?: Fr; counter?: number }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    this.nullifierReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), this.contractAddress));
+    return this;
+  }
+
+  /** Adds a settled nullifier read request (empty contract address, resolved against the nullifier tree). */
+  addSettledNullifierReadRequest(opts?: { value?: Fr; counter?: number }): this {
+    const value = opts?.value ?? Fr.random();
+    const counter = this.getCounter(opts?.counter);
+    this.nullifierReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), AztecAddress.ZERO));
+    return this;
+  }
+
+  /** Adds a key validation request. */
+  addKeyValidationRequest(): this {
+    this.keyValidationRequests.push(
+      new KeyValidationRequestAndSeparator(
+        new KeyValidationRequest(new Point(Fr.random(), Fr.random(), false), Fr.random()),
+        Fr.random(),
+      ),
+    );
+    return this;
+  }
+
+  /** Adds a private log. Defaults are generated randomly. */
+  addPrivateLog(opts?: { noteHashCounter?: number; counter?: number }): this {
+    const noteHashCounter = opts?.noteHashCounter ?? 0;
+    const counter = this.getCounter(opts?.counter);
+    this.privateLogs.push(new PrivateLogData(PrivateLog.empty(), noteHashCounter, counter));
+    return this;
+  }
+
+  /** Builds the PrivateCircuitPublicInputs with all added side effects. */
+  build(): PrivateCircuitPublicInputs {
+    const publicInputs = PrivateCircuitPublicInputs.empty();
+    publicInputs.callContext.contractAddress = this.contractAddress;
+    publicInputs.noteHashes = makeClaimed(this.noteHashes, NoteHash, MAX_NOTE_HASHES_PER_CALL);
+    publicInputs.nullifiers = makeClaimed(this.nullifiers, Nullifier, MAX_NULLIFIERS_PER_CALL);
+    publicInputs.privateLogs = makeClaimed(this.privateLogs, PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL);
+    publicInputs.noteHashReadRequests = makeClaimed(
+      this.noteHashReadRequests,
+      ScopedReadRequest,
+      MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+    );
+    publicInputs.nullifierReadRequests = makeClaimed(
+      this.nullifierReadRequests,
+      ScopedReadRequest,
+      MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+    );
+    publicInputs.keyValidationRequestsAndSeparators = makeClaimed(
+      this.keyValidationRequests,
+      KeyValidationRequestAndSeparator,
+      MAX_KEY_VALIDATION_REQUESTS_PER_CALL,
+    );
+    return publicInputs;
+  }
+}
+
+/** Wraps a PrivateKernelCircuitPublicInputs in a PrivateKernelSimulateOutput. */
+export function makeKernelOutput(
+  publicInputs?: PrivateKernelCircuitPublicInputs,
+): PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs> {
+  return {
+    publicInputs: publicInputs ?? PrivateKernelCircuitPublicInputs.empty(),
+    verificationKey: VerificationKeyData.empty(),
+    outputWitness: new Map(),
+    bytecode: Buffer.from([]),
+  };
+}
+
+/** Wraps a PrivateCircuitPublicInputs in a PrivateCallExecutionResult. */
+export function makeExecutionResult(publicInputs?: PrivateCircuitPublicInputs): PrivateCallExecutionResult {
+  return new PrivateCallExecutionResult(
+    Buffer.alloc(0),
+    Buffer.alloc(0),
+    new Map(),
+    publicInputs ?? PrivateCircuitPublicInputs.empty(),
+    [],
+    new Map(),
+    [],
+    [],
+    [],
+    [],
+    [],
+  );
+}

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -116,6 +116,7 @@ export class PrivateKernelExecutionProver {
           splitCounter,
         );
         while (resetBuilder.needsReset()) {
+          // Inner reset: without siloing.
           const witgenTimer = new Timer();
           const privateInputs = await resetBuilder.build(this.oracle);
           output = generateWitnesses
@@ -216,16 +217,24 @@ export class PrivateKernelExecutionProver {
       firstIteration = false;
     }
 
-    // Reset.
-    let resetBuilder = new PrivateKernelResetPrivateInputsBuilder(
+    // Final reset: include siloing of note hashes, nullifiers and private logs.
+    const finalResetBuilder = new PrivateKernelResetPrivateInputsBuilder(
       output,
       [],
       noteHashNullifierCounterMap,
       splitCounter,
     );
-    while (resetBuilder.needsReset()) {
+    if (!finalResetBuilder.needsReset()) {
+      // The final reset must be performed exactly once, because each tx has at least one nullifier that requires
+      // siloing, and siloing cannot be done multiple times.
+      // While, in theory, it might be possible to silo note hashes first and then run another reset to silo nullifiers
+      // and/or private logs, we currently don't have standalone dimensions for the arrays that require siloing. As a
+      // result, all necessary siloing must be done together in a single reset.
+      // Refer to the possible combinations of dimensions in private_kernel_reset_config.json.
+      throw new Error('Nothing to reset for the final reset.');
+    } else {
       const witgenTimer = new Timer();
-      const privateInputs = await resetBuilder.build(this.oracle);
+      const privateInputs = await finalResetBuilder.build(this.oracle);
       output = generateWitnesses
         ? await this.proofCreator.generateResetOutput(privateInputs)
         : await this.proofCreator.simulateReset(privateInputs);
@@ -239,8 +248,6 @@ export class PrivateKernelExecutionProver {
           witgen: witgenTimer.ms(),
         },
       });
-
-      resetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, [], noteHashNullifierCounterMap, splitCounter);
     }
 
     if (output.publicInputs.feePayer.isZero() && skipFeeEnforcement) {

package/src/private_kernel/private_kernel_oracle.ts

@@ -8,11 +8,7 @@ import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { BlockHash } from '@aztec/stdlib/block';
-import {
-  type ContractInstanceWithAddress,
-  computeContractClassIdPreimage,
-  computeSaltedInitializationHash,
-} from '@aztec/stdlib/contract';
+import { type ContractInstanceWithAddress, computeSaltedInitializationHash } from '@aztec/stdlib/contract';
 import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
@@ -49,11 +45,15 @@ export class PrivateKernelOracle {
 
   /** Retrieves the preimage of a contract class id from the contract classes db. */
   public async getContractClassIdPreimage(contractClassId: Fr) {
-    const contractClass = await this.contractStore.getContractClass(contractClassId);
+    const contractClass = await this.contractStore.getContractClassWithPreimage(contractClassId);
     if (!contractClass) {
       throw new Error(`Contract class not found when getting class id preimage. Class id: ${contractClassId}.`);
     }
-    return computeContractClassIdPreimage(contractClass);
+    return {
+      artifactHash: contractClass.artifactHash,
+      privateFunctionsRoot: contractClass.privateFunctionsRoot,
+      publicBytecodeCommitment: contractClass.publicBytecodeCommitment,
+    };
   }
 
   /** Returns a membership witness with the sibling path and leaf index in our private functions tree. */

package/src/pxe.ts

@@ -61,6 +61,7 @@ import {
   generateSimulatedProvingResult,
 } from './contract_function_simulator/contract_function_simulator.js';
 import { ProxiedContractStoreFactory } from './contract_function_simulator/proxied_contract_data_source.js';
+import { displayDebugLogs } from './contract_logging.js';
 import { ContractSyncService } from './contract_sync/contract_sync_service.js';
 import { readCurrentClassId } from './contract_sync/helpers.js';
 import { PXEDebugUtils } from './debug/pxe_debug_utils.js';
@@ -144,6 +145,7 @@ export type PXECreateArgs = {
 export class PXE {
   private constructor(
     private node: AztecNode,
+    private db: AztecAsyncKVStore,
     private blockStateSynchronizer: BlockSynchronizer,
     private keyStore: KeyStore,
     private contractStore: ContractStore,
@@ -239,6 +241,7 @@ export class PXE {
 
     const pxe = new PXE(
       node,
+      store,
       synchronizer,
       keyStore,
       contractStore,
@@ -344,9 +347,8 @@ export class PXE {
   async #registerProtocolContracts() {
     const registered: Record<string, string> = {};
     for (const name of protocolContractNames) {
-      const { address, contractClass, instance, artifact } =
-        await this.protocolContractsProvider.getProtocolContractArtifact(name);
-      await this.contractStore.addContractArtifact(contractClass.id, artifact);
+      const { address, instance, artifact } = await this.protocolContractsProvider.getProtocolContractArtifact(name);
+      await this.contractStore.addContractArtifact(artifact);
       await this.contractStore.addContractInstance(instance);
       registered[name] = address.toString();
     }
@@ -601,8 +603,7 @@ export class PXE {
    * @param artifact - The build artifact for the contract class.
    */
   public async registerContractClass(artifact: ContractArtifact): Promise<void> {
-    const { id: contractClassId } = await getContractClassFromArtifact(artifact);
-    await this.contractStore.addContractArtifact(contractClassId, artifact);
+    const contractClassId = await this.contractStore.addContractArtifact(artifact);
     this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
   }
 
@@ -621,17 +622,17 @@ export class PXE {
     if (artifact) {
       // If the user provides an artifact, validate it against the expected class id and register it
       const contractClass = await getContractClassFromArtifact(artifact);
-      const contractClassId = contractClass.id;
-      if (!contractClassId.equals(instance.currentContractClassId)) {
+      if (!contractClass.id.equals(instance.currentContractClassId)) {
         throw new Error(
-          `Artifact does not match expected class id (computed ${contractClassId} but instance refers to ${instance.currentContractClassId})`,
+          `Artifact does not match expected class id (computed ${contractClass.id} but instance refers to ${instance.currentContractClassId})`,
         );
       }
       const computedAddress = await computeContractAddressFromInstance(instance);
       if (!computedAddress.equals(instance.address)) {
         throw new Error('Added a contract in which the address does not match the contract instance.');
       }
-      await this.contractStore.addContractArtifact(contractClass.id, artifact);
+
+      await this.contractStore.addContractArtifact(artifact, contractClass);
 
       const publicFunctionSignatures = artifact.functions
         .filter(fn => fn.functionType === FunctionType.PUBLIC)
@@ -680,15 +681,16 @@ export class PXE {
         throw new Error('Could not update contract to a class different from the current one.');
       }
 
-      await this.contractStore.addContractArtifact(contractClass.id, artifact);
-
       const publicFunctionSignatures = artifact.functions
         .filter(fn => fn.functionType === FunctionType.PUBLIC)
         .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
       await this.node.registerContractFunctionSignatures(publicFunctionSignatures);
 
       currentInstance.currentContractClassId = contractClass.id;
-      await this.contractStore.addContractInstance(currentInstance);
+      await Promise.all([
+        this.contractStore.addContractArtifact(artifact, contractClass),
+        this.contractStore.addContractInstance(currentInstance),
+      ]);
       this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
     });
   }
@@ -947,6 +949,9 @@ export class PXE {
           const publicSimulationTimer = new Timer();
           publicOutput = await this.#simulatePublicCalls(simulatedTx, skipFeeEnforcement);
           publicSimulationTime = publicSimulationTimer.ms();
+          if (publicOutput?.debugLogs?.length) {
+            await displayDebugLogs(publicOutput.debugLogs, addr => this.contractStore.getDebugContractName(addr));
+          }
         }
 
         let validationTime: number | undefined;
@@ -955,7 +960,8 @@ export class PXE {
           const validationResult = await this.node.isValidTx(simulatedTx, { isSimulation: true, skipFeeEnforcement });
           validationTime = validationTimer.ms();
           if (validationResult.result === 'invalid') {
-            throw new Error('The simulated transaction is unable to be added to state and is invalid.');
+            const reason = validationResult.reason.length > 0 ? ` Reason: ${validationResult.reason.join(', ')}` : '';
+            throw new Error(`The simulated transaction is unable to be added to state and is invalid.${reason}`);
           }
         }
 
@@ -1126,9 +1132,10 @@ export class PXE {
   }
 
   /**
-   * Stops the PXE's job queue.
+   * Stops the PXE's job queue and closes the backing store.
    */
-  public stop(): Promise<void> {
-    return this.jobQueue.end();
+  public async stop(): Promise<void> {
+    await this.jobQueue.end();
+    await this.db.close();
   }
 }