@aztec/txe 0.69.1 → 0.71.0

package/src/oracle/txe_oracle.ts

@@ -58,31 +58,32 @@ import {
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
-import { type Logger, applyStringFormatting } from '@aztec/foundation/log';
+import { type LogFn, type Logger, applyStringFormatting, createDebugOnlyLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { type KeyStore } from '@aztec/key-store';
 import { ContractDataOracle, SimulatorOracle, enrichPublicSimulationError } from '@aztec/pxe';
 import {
-  ExecutionError,
   ExecutionNoteCache,
   type MessageLoadOracleInputs,
   type NoteData,
   Oracle,
-  type PackedValuesCache,
-  type PublicTxResult,
-  PublicTxSimulator,
   type TypedOracle,
-  acvm,
-  createSimulationError,
+  WASMSimulator,
   extractCallStack,
   extractPrivateCircuitPublicInputs,
   pickNotes,
-  resolveAssertionMessageFromError,
   toACVMWitness,
   witnessMapToFields,
-} from '@aztec/simulator';
-import { createTxForPublicCall } from '@aztec/simulator/public/fixtures';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+} from '@aztec/simulator/client';
+import { createTxForPublicCalls } from '@aztec/simulator/public/fixtures';
+import {
+  ExecutionError,
+  type HashedValuesCache,
+  type PublicTxResult,
+  PublicTxSimulator,
+  createSimulationError,
+  resolveAssertionMessageFromError,
+} from '@aztec/simulator/server';
 import { MerkleTreeSnapshotOperationsFacade, type MerkleTrees } from '@aztec/world-state';
 
 import { TXENode } from '../node/txe_node.js';
@@ -103,32 +104,48 @@ export class TXE implements TypedOracle {
   private contractDataOracle: ContractDataOracle;
   private simulatorOracle: SimulatorOracle;
 
-  private version: Fr = Fr.ONE;
-  private chainId: Fr = Fr.ONE;
-
   private uniqueNoteHashesFromPublic: Fr[] = [];
   private siloedNullifiersFromPublic: Fr[] = [];
-  private siloedNullifiersFromPrivate: Set<string> = new Set();
   private privateLogs: PrivateLog[] = [];
   private publicLogs: UnencryptedL2Log[] = [];
 
   private committedBlocks = new Set<number>();
 
-  private node = new TXENode(this.blockNumber);
+  private VERSION = 1;
+  private CHAIN_ID = 1;
+
+  private node: TXENode;
+
+  private simulationProvider = new WASMSimulator();
+
+  private noteCache: ExecutionNoteCache;
+
+  debug: LogFn;
 
   constructor(
     private logger: Logger,
     private trees: MerkleTrees,
-    private packedValuesCache: PackedValuesCache,
-    private noteCache: ExecutionNoteCache,
+    private executionCache: HashedValuesCache,
     private keyStore: KeyStore,
     private txeDatabase: TXEDatabase,
   ) {
+    this.noteCache = new ExecutionNoteCache(this.getTxRequestHash());
     this.contractDataOracle = new ContractDataOracle(txeDatabase);
     this.contractAddress = AztecAddress.random();
+
+    this.node = new TXENode(this.blockNumber, this.VERSION, this.CHAIN_ID, this.trees);
+
     // Default msg_sender (for entrypoints) is now Fr.max_value rather than 0 addr (see #7190 & #7404)
     this.msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE);
-    this.simulatorOracle = new SimulatorOracle(this.contractDataOracle, txeDatabase, keyStore, this.node);
+    this.simulatorOracle = new SimulatorOracle(
+      this.contractDataOracle,
+      txeDatabase,
+      keyStore,
+      this.node,
+      this.simulationProvider,
+    );
+
+    this.debug = createDebugOnlyLogger('aztec:kv-pxe-database');
   }
 
   // Utils
@@ -141,12 +158,12 @@ export class TXE implements TypedOracle {
     return db;
   }
 
-  getChainId() {
-    return Promise.resolve(this.chainId);
+  getChainId(): Promise<Fr> {
+    return Promise.resolve(this.node.getChainId().then(id => new Fr(id)));
   }
 
-  getVersion() {
-    return Promise.resolve(this.version);
+  getVersion(): Promise<Fr> {
+    return Promise.resolve(this.node.getVersion().then(v => new Fr(v)));
   }
 
   getMsgSender() {
@@ -217,8 +234,8 @@ export class TXE implements TypedOracle {
 
     const stateReference = await db.getStateReference();
     const inputs = PrivateContextInputs.empty();
-    inputs.txContext.chainId = this.chainId;
-    inputs.txContext.version = this.version;
+    inputs.txContext.chainId = new Fr(await this.node.getChainId());
+    inputs.txContext.version = new Fr(await this.node.getVersion());
     inputs.historicalHeader.globalVariables.blockNumber = new Fr(blockNumber);
     inputs.historicalHeader.state = stateReference;
     inputs.historicalHeader.lastArchive.root = Fr.fromBuffer(
@@ -260,18 +277,14 @@ export class TXE implements TypedOracle {
     );
   }
 
-  async addNullifiersFromPrivate(contractAddress: AztecAddress, nullifiers: Fr[]) {
+  async checkNullifiersNotInTree(contractAddress: AztecAddress, nullifiers: Fr[]) {
     const siloedNullifiers = nullifiers.map(nullifier => siloNullifier(contractAddress, nullifier));
     const db = await this.trees.getLatest();
     const nullifierIndexesInTree = await db.findLeafIndices(
       MerkleTreeId.NULLIFIER_TREE,
       siloedNullifiers.map(n => n.toBuffer()),
     );
-    const notInTree = nullifierIndexesInTree.every(index => index === undefined);
-    const notInCache = siloedNullifiers.every(n => !this.siloedNullifiersFromPrivate.has(n.toString()));
-    if (notInTree && notInCache) {
-      siloedNullifiers.forEach(n => this.siloedNullifiersFromPrivate.add(n.toString()));
-    } else {
+    if (nullifierIndexesInTree.some(index => index !== undefined)) {
       throw new Error(`Rejecting tx for emitting duplicate nullifiers`);
     }
   }
@@ -360,16 +373,16 @@ export class TXE implements TypedOracle {
     return Fr.random();
   }
 
-  packArgumentsArray(args: Fr[]) {
-    return Promise.resolve(this.packedValuesCache.pack(args));
+  storeArrayInExecutionCache(values: Fr[]) {
+    return Promise.resolve(this.executionCache.store(values));
   }
 
-  packReturns(returns: Fr[]) {
-    return Promise.resolve(this.packedValuesCache.pack(returns));
+  storeInExecutionCache(values: Fr[]) {
+    return Promise.resolve(this.executionCache.store(values));
   }
 
-  unpackReturns(returnsHash: Fr) {
-    return Promise.resolve(this.packedValuesCache.unpack(returnsHash));
+  loadFromExecutionCache(returnsHash: Fr) {
+    return Promise.resolve(this.executionCache.getPreimage(returnsHash));
   }
 
   getKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest> {
@@ -395,11 +408,11 @@ export class TXE implements TypedOracle {
     return [new Fr(index), ...siblingPath.toFields()];
   }
 
-  async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr) {
-    const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
-    const result = await committedDb.getSiblingPath(treeId, leafIndex.toBigInt());
-    return result.toFields();
-  }
+  // async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr) {
+  //   const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+  //   const result = await committedDb.getSiblingPath(treeId, leafIndex.toBigInt());
+  //   return result.toFields();
+  // }
 
   async getNullifierMembershipWitness(
     blockNumber: number,
@@ -550,12 +563,18 @@ export class TXE implements TypedOracle {
   }
 
   async notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
-    await this.addNullifiersFromPrivate(this.contractAddress, [innerNullifier]);
+    await this.checkNullifiersNotInTree(this.contractAddress, [innerNullifier]);
     this.noteCache.nullifyNote(this.contractAddress, innerNullifier, noteHash);
     this.sideEffectCounter = counter + 1;
     return Promise.resolve();
   }
 
+  async notifyCreatedNullifier(innerNullifier: Fr): Promise<void> {
+    await this.checkNullifiersNotInTree(this.contractAddress, [innerNullifier]);
+    this.noteCache.nullifierCreated(this.contractAddress, innerNullifier);
+    return Promise.resolve();
+  }
+
   async checkNullifierExists(innerNullifier: Fr): Promise<boolean> {
     const nullifier = siloNullifier(this.contractAddress, innerNullifier!);
     const db = await this.trees.getLatest();
@@ -617,6 +636,7 @@ export class TXE implements TypedOracle {
 
   async commitState() {
     const blockNumber = await this.getBlockNumber();
+    const { usedTxRequestHashForNonces } = this.noteCache.finish();
     if (this.committedBlocks.has(blockNumber)) {
       throw new Error('Already committed state');
     } else {
@@ -625,30 +645,25 @@ export class TXE implements TypedOracle {
 
     const txEffect = TxEffect.empty();
 
+    const nonceGenerator = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
+
     let i = 0;
     txEffect.noteHashes = [
       ...this.noteCache
         .getAllNotes()
         .map(pendingNote =>
           computeUniqueNoteHash(
-            computeNoteHashNonce(new Fr(this.blockNumber + 6969), i++),
+            computeNoteHashNonce(nonceGenerator, i++),
             siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption),
           ),
         ),
       ...this.uniqueNoteHashesFromPublic,
     ];
-    txEffect.nullifiers = [
-      new Fr(blockNumber + 6969),
-      ...Array.from(this.siloedNullifiersFromPrivate).map(n => Fr.fromString(n)),
-    ];
-
-    // Using block number itself, (without adding 6969) gets killed at 1 as it says the slot is already used,
-    // it seems like we commit a 1 there to the trees before ? To see what I mean, uncomment these lines below
-    // let index = await (await this.trees.getLatest()).findLeafIndex(MerkleTreeId.NULLIFIER_TREE, Fr.ONE.toBuffer());
-    // console.log('INDEX OF ONE', index);
-    // index = await (await this.trees.getLatest()).findLeafIndex(MerkleTreeId.NULLIFIER_TREE, Fr.random().toBuffer());
-    // console.log('INDEX OF RANDOM', index);
 
+    txEffect.nullifiers = this.noteCache.getAllNullifiers();
+    if (usedTxRequestHashForNonces) {
+      txEffect.nullifiers.unshift(this.getTxRequestHash());
+    }
     this.node.setTxEffect(blockNumber, new TxHash(new Fr(blockNumber)), txEffect);
     this.node.setNullifiersIndexesWithBlock(blockNumber, txEffect.nullifiers);
     this.node.addNoteLogsByTags(this.blockNumber, this.privateLogs);
@@ -659,10 +674,14 @@ export class TXE implements TypedOracle {
 
     this.privateLogs = [];
     this.publicLogs = [];
-    this.siloedNullifiersFromPrivate = new Set();
     this.uniqueNoteHashesFromPublic = [];
     this.siloedNullifiersFromPublic = [];
-    this.noteCache = new ExecutionNoteCache(new Fr(1));
+    this.noteCache = new ExecutionNoteCache(this.getTxRequestHash());
+  }
+
+  getTxRequestHash() {
+    // Using block number itself is invalid since indexed trees come prefilled with the first slots.
+    return new Fr(this.blockNumber + 6969);
   }
 
   emitContractClassLog(_log: UnencryptedL2Log, _counter: number): Fr {
@@ -697,21 +716,23 @@ export class TXE implements TypedOracle {
     const initialWitness = await this.getInitialWitness(artifact, argsHash, sideEffectCounter, isStaticCall);
     const acvmCallback = new Oracle(this);
     const timer = new Timer();
-    const acirExecutionResult = await acvm(acir, initialWitness, acvmCallback).catch((err: Error) => {
-      err.message = resolveAssertionMessageFromError(err, artifact);
-
-      const execError = new ExecutionError(
-        err.message,
-        {
-          contractAddress: targetContractAddress,
-          functionSelector,
-        },
-        extractCallStack(err, artifact.debug),
-        { cause: err },
-      );
-      this.logger.debug(`Error executing private function ${targetContractAddress}:${functionSelector}`);
-      throw createSimulationError(execError);
-    });
+    const acirExecutionResult = await this.simulationProvider
+      .executeUserCircuit(acir, initialWitness, acvmCallback)
+      .catch((err: Error) => {
+        err.message = resolveAssertionMessageFromError(err, artifact);
+
+        const execError = new ExecutionError(
+          err.message,
+          {
+            contractAddress: targetContractAddress,
+            functionSelector,
+          },
+          extractCallStack(err, artifact.debug),
+          { cause: err },
+        );
+        this.logger.debug(`Error executing private function ${targetContractAddress}:${functionSelector}`);
+        throw createSimulationError(execError);
+      });
     const duration = timer.ms();
     const publicInputs = extractPrivateCircuitPublicInputs(artifact, acirExecutionResult.partialWitness);
 
@@ -734,24 +755,6 @@ export class TXE implements TypedOracle {
       publicInputs.privateLogs.filter(privateLog => !privateLog.isEmpty()).map(privateLog => privateLog.log),
     );
 
-    const executionNullifiers = publicInputs.nullifiers
-      .filter(nullifier => !nullifier.isEmpty())
-      .map(nullifier => nullifier.value);
-    // We inject nullifiers into siloedNullifiersFromPrivate from notifyNullifiedNote,
-    // so top level calls to destroyNote work as expected. As such, we are certain
-    // that we would insert duplicates if we just took the nullifiers from the public inputs and
-    // blindly inserted them into siloedNullifiersFromPrivate. To avoid this, we extract the first
-    // (and only the first!) duplicated nullifier from the public inputs, so we can just push
-    // the ones that were not created by deleting a note
-    const firstDuplicateIndexes = executionNullifiers
-      .map((nullifier, index) => {
-        const siloedNullifier = siloNullifier(targetContractAddress, nullifier);
-        return this.siloedNullifiersFromPrivate.has(siloedNullifier.toString()) ? index : -1;
-      })
-      .filter(index => index !== -1);
-    const nonNoteNullifiers = executionNullifiers.filter((_, index) => !firstDuplicateIndexes.includes(index));
-    await this.addNullifiersFromPrivate(targetContractAddress, nonNoteNullifiers);
-
     this.setContractAddress(currentContractAddress);
     this.setMsgSender(currentMessageSender);
     this.setFunctionSelector(currentFunctionSelector);
@@ -762,7 +765,7 @@ export class TXE implements TypedOracle {
   async getInitialWitness(abi: FunctionAbi, argsHash: Fr, sideEffectCounter: number, isStaticCall: boolean) {
     const argumentsSize = countArgumentsSize(abi);
 
-    const args = this.packedValuesCache.unpack(argsHash);
+    const args = this.executionCache.getPreimage(argsHash);
 
     if (args.length !== argumentsSize) {
       throw new Error('Invalid arguments size');
@@ -809,8 +812,8 @@ export class TXE implements TypedOracle {
     const worldStateDb = new TXEWorldStateDB(db, new TXEPublicContractDataSource(this));
 
     const globalVariables = GlobalVariables.empty();
-    globalVariables.chainId = this.chainId;
-    globalVariables.version = this.version;
+    globalVariables.chainId = new Fr(await this.node.getChainId());
+    globalVariables.version = new Fr(await this.node.getVersion());
     globalVariables.blockNumber = new Fr(this.blockNumber);
     globalVariables.gasFees = new GasFees(1, 1);
 
@@ -829,14 +832,18 @@ export class TXE implements TypedOracle {
     const simulator = new PublicTxSimulator(
       db,
       new TXEWorldStateDB(db, new TXEPublicContractDataSource(this)),
-      new NoopTelemetryClient(),
       globalVariables,
     );
 
     // When setting up a teardown call, we tell it that
     // private execution used Gas(1, 1) so it can compute a tx fee.
     const gasUsedByPrivate = isTeardown ? new Gas(1, 1) : Gas.empty();
-    const tx = createTxForPublicCall(executionRequest, gasUsedByPrivate, isTeardown);
+    const tx = createTxForPublicCalls(
+      /*setupExecutionRequests=*/ [],
+      /*appExecutionRequests=*/ isTeardown ? [] : [executionRequest],
+      /*teardownExecutionRequests=*/ isTeardown ? executionRequest : undefined,
+      gasUsedByPrivate,
+    );
 
     const result = await simulator.simulate(tx);
 
@@ -868,8 +875,8 @@ export class TXE implements TypedOracle {
       isStaticCall,
     );
 
-    const args = [this.functionSelector.toField(), ...this.packedValuesCache.unpack(argsHash)];
-    const newArgsHash = this.packedValuesCache.pack(args);
+    const args = [this.functionSelector.toField(), ...this.executionCache.getPreimage(argsHash)];
+    const newArgsHash = this.executionCache.store(args);
 
     const executionResult = await this.executePublicFunction(args, callContext, isTeardown);
 
@@ -968,6 +975,19 @@ export class TXE implements TypedOracle {
     return Promise.resolve();
   }
 
+  deliverNote(
+    _contractAddress: AztecAddress,
+    _storageSlot: Fr,
+    _nonce: Fr,
+    _content: Fr[],
+    _noteHash: Fr,
+    _nullifier: Fr,
+    _txHash: Fr,
+    _recipient: AztecAddress,
+  ): Promise<void> {
+    throw new Error('deliverNote');
+  }
+
   // AVM oracles
 
   async avmOpcodeCall(targetContractAddress: AztecAddress, args: Fr[], isStaticCall: boolean): Promise<PublicTxResult> {
@@ -1051,4 +1071,36 @@ export class TXE implements TypedOracle {
 
     return preimage.value;
   }
+
+  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+    }
+    return this.txeDatabase.dbStore(this.contractAddress, slot, values);
+  }
+
+  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+    }
+    return this.txeDatabase.dbLoad(this.contractAddress, slot);
+  }
+
+  dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+    }
+    return this.txeDatabase.dbDelete(this.contractAddress, slot);
+  }
+
+  dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+    }
+    return this.txeDatabase.dbCopy(this.contractAddress, srcSlot, dstSlot, numEntries);
+  }
 }

package/src/txe_service/txe_service.ts

@@ -18,8 +18,9 @@ import { openTmpStore } from '@aztec/kv-store/lmdb';
 import { protocolContractNames } from '@aztec/protocol-contracts';
 import { getCanonicalProtocolContract } from '@aztec/protocol-contracts/bundle';
 import { enrichPublicSimulationError } from '@aztec/pxe';
-import { ExecutionNoteCache, PackedValuesCache, type TypedOracle } from '@aztec/simulator';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+import { type TypedOracle } from '@aztec/simulator/client';
+import { HashedValuesCache } from '@aztec/simulator/server';
+import { getTelemetryClient } from '@aztec/telemetry-client';
 import { MerkleTrees } from '@aztec/world-state';
 
 import { TXE } from '../oracle/txe_oracle.js';
@@ -41,10 +42,8 @@ export class TXEService {
 
   static async init(logger: Logger) {
     const store = openTmpStore(true);
-    const trees = await MerkleTrees.new(store, new NoopTelemetryClient(), logger);
-    const packedValuesCache = new PackedValuesCache();
-    const txHash = new Fr(1); // The txHash is used for computing the revertible nullifiers for non-revertible note hashes. It can be any value for testing.
-    const noteCache = new ExecutionNoteCache(txHash);
+    const trees = await MerkleTrees.new(store, getTelemetryClient(), logger);
+    const executionCache = new HashedValuesCache();
     const keyStore = new KeyStore(store);
     const txeDatabase = new TXEDatabase(store);
     // Register protocol contracts.
@@ -54,7 +53,7 @@ export class TXEService {
       await txeDatabase.addContractInstance(instance);
     }
     logger.debug(`TXE service initialized`);
-    const txe = new TXE(logger, trees, packedValuesCache, noteCache, keyStore, txeDatabase);
+    const txe = new TXE(logger, trees, executionCache, keyStore, txeDatabase);
     const service = new TXEService(logger, txe);
     await service.advanceBlocksBy(toSingle(new Fr(1n)));
     return service;
@@ -272,25 +271,20 @@ export class TXEService {
     return toForeignCallResult([toSingle(new Fr(blockNumber))]);
   }
 
-  async packArgumentsArray(args: ForeignCallArray) {
-    const packed = await this.typedOracle.packArgumentsArray(fromArray(args));
-    return toForeignCallResult([toSingle(packed)]);
-  }
-
-  async packArguments(_length: ForeignCallSingle, values: ForeignCallArray) {
-    const packed = await this.typedOracle.packArgumentsArray(fromArray(values));
-    return toForeignCallResult([toSingle(packed)]);
+  async storeArrayInExecutionCache(args: ForeignCallArray) {
+    const hash = await this.typedOracle.storeArrayInExecutionCache(fromArray(args));
+    return toForeignCallResult([toSingle(hash)]);
   }
 
   // Since the argument is a slice, noir automatically adds a length field to oracle call.
-  async packReturns(_length: ForeignCallSingle, values: ForeignCallArray) {
-    const packed = await this.typedOracle.packReturns(fromArray(values));
-    return toForeignCallResult([toSingle(packed)]);
+  async storeInExecutionCache(_length: ForeignCallSingle, values: ForeignCallArray) {
+    const returnsHash = await this.typedOracle.storeInExecutionCache(fromArray(values));
+    return toForeignCallResult([toSingle(returnsHash)]);
   }
 
-  async unpackReturns(returnsHash: ForeignCallSingle) {
-    const unpacked = await this.typedOracle.unpackReturns(fromSingle(returnsHash));
-    return toForeignCallResult([toArray(unpacked)]);
+  async loadFromExecutionCache(hash: ForeignCallSingle) {
+    const returns = await this.typedOracle.loadFromExecutionCache(fromSingle(hash));
+    return toForeignCallResult([toArray(returns)]);
   }
 
   // Since the argument is a slice, noir automatically adds a length field to oracle call.
@@ -334,15 +328,6 @@ export class TXEService {
     return toForeignCallResult([toArray(witness.toFields())]);
   }
 
-  async getSiblingPath(blockNumber: ForeignCallSingle, treeId: ForeignCallSingle, leafIndex: ForeignCallSingle) {
-    const result = await this.typedOracle.getSiblingPath(
-      fromSingle(blockNumber).toNumber(),
-      fromSingle(treeId).toNumber(),
-      fromSingle(leafIndex),
-    );
-    return toForeignCallResult([toArray(result)]);
-  }
-
   async getNotes(
     storageSlot: ForeignCallSingle,
     numSelects: ForeignCallSingle,
@@ -434,6 +419,11 @@ export class TXEService {
     return toForeignCallResult([toSingle(new Fr(0))]);
   }
 
+  async notifyCreatedNullifier(innerNullifier: ForeignCallSingle) {
+    await this.typedOracle.notifyCreatedNullifier(fromSingle(innerNullifier));
+    return toForeignCallResult([toSingle(new Fr(0))]);
+  }
+
   async checkNullifierExists(innerNullifier: ForeignCallSingle) {
     const exists = await this.typedOracle.checkNullifierExists(fromSingle(innerNullifier));
     return toForeignCallResult([toSingle(new Fr(exists))]);
@@ -598,6 +588,49 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
+  async dbStore(contractAddress: ForeignCallSingle, slot: ForeignCallSingle, values: ForeignCallArray) {
+    await this.typedOracle.dbStore(
+      AztecAddress.fromField(fromSingle(contractAddress)),
+      fromSingle(slot),
+      fromArray(values),
+    );
+    return toForeignCallResult([]);
+  }
+
+  async dbLoad(contractAddress: ForeignCallSingle, slot: ForeignCallSingle, tSize: ForeignCallSingle) {
+    const values = await this.typedOracle.dbLoad(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot));
+    // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
+    // with two fields: `some` (a boolean) and `value` (a field array in this case).
+    if (values === null) {
+      // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
+      return toForeignCallResult([toSingle(new Fr(0)), toArray(Array(fromSingle(tSize).toNumber()).fill(new Fr(0)))]);
+    } else {
+      // Data was found so we set `some` to 1 and return it along with `value`.
+      return toForeignCallResult([toSingle(new Fr(1)), toArray(values)]);
+    }
+  }
+
+  async dbDelete(contractAddress: ForeignCallSingle, slot: ForeignCallSingle) {
+    await this.typedOracle.dbDelete(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot));
+    return toForeignCallResult([]);
+  }
+
+  async dbCopy(
+    contractAddress: ForeignCallSingle,
+    srcSlot: ForeignCallSingle,
+    dstSlot: ForeignCallSingle,
+    numEntries: ForeignCallSingle,
+  ) {
+    await this.typedOracle.dbCopy(
+      AztecAddress.fromField(fromSingle(contractAddress)),
+      fromSingle(srcSlot),
+      fromSingle(dstSlot),
+      fromSingle(numEntries).toNumber(),
+    );
+
+    return toForeignCallResult([]);
+  }
+
   // AVM opcodes
 
   avmOpcodeEmitUnencryptedLog(_message: ForeignCallArray) {

package/src/util/txe_world_state_db.ts

@@ -7,7 +7,7 @@ import {
   type PublicDataTreeLeafPreimage,
 } from '@aztec/circuits.js';
 import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
-import { WorldStateDB } from '@aztec/simulator';
+import { WorldStateDB } from '@aztec/simulator/server';
 
 export class TXEWorldStateDB extends WorldStateDB {
   constructor(private merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource) {