@aztec/txe 0.69.1 → 0.70.0

package/src/oracle/txe_oracle.ts

@@ -58,30 +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';
+} 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 { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTreeSnapshotOperationsFacade, type MerkleTrees } from '@aztec/world-state';
 
@@ -108,7 +110,6 @@ export class TXE implements TypedOracle {
 
   private uniqueNoteHashesFromPublic: Fr[] = [];
   private siloedNullifiersFromPublic: Fr[] = [];
-  private siloedNullifiersFromPrivate: Set<string> = new Set();
   private privateLogs: PrivateLog[] = [];
   private publicLogs: UnencryptedL2Log[] = [];
 
@@ -116,19 +117,33 @@ export class TXE implements TypedOracle {
 
   private node = new TXENode(this.blockNumber);
 
+  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();
     // 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
@@ -260,18 +275,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 +371,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> {
@@ -550,12 +561,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 +634,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 +643,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 +672,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 +714,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 +753,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 +763,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');
@@ -836,7 +837,12 @@ export class TXE implements TypedOracle {
     // 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 +874,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);
 
@@ -1051,4 +1057,37 @@ export class TXE implements TypedOracle {
 
     return preimage.value;
   }
+
+  /**
+   * Used by contracts during execution to store arbitrary data in the local PXE database. The data is siloed/scoped
+   * to a specific `contract`.
+   * @param contract - The contract address to store the data under.
+   * @param key - A field element representing the key to store the data under.
+   * @param values - An array of field elements representing the data to store.
+   */
+  store(contract: AztecAddress, key: Fr, values: Fr[]): Promise<void> {
+    if (!contract.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check check that this.contractAddress is allowed to process notes for contract
+      throw new Error(
+        `Contract address ${contract} does not match the oracle's contract address ${this.contractAddress}`,
+      );
+    }
+    return this.txeDatabase.store(this.contractAddress, key, values);
+  }
+
+  /**
+   * Used by contracts during execution to load arbitrary data from the local PXE database. The data is siloed/scoped
+   * to a specific `contract`.
+   * @param contract - The contract address to load the data from.
+   * @param key - A field element representing the key under which to load the data..
+   * @returns An array of field elements representing the stored data or `null` if no data is stored under the key.
+   */
+  load(contract: AztecAddress, key: Fr): Promise<Fr[] | null> {
+    if (!contract.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check check that this.contractAddress is allowed to process notes for contract
+      this.debug(`Data not found for contract ${contract.toString()} and key ${key.toString()}`);
+      return Promise.resolve(null);
+    }
+    return this.txeDatabase.load(this.contractAddress, key);
+  }
 }

package/src/txe_service/txe_service.ts

@@ -18,7 +18,8 @@ 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 { type TypedOracle } from '@aztec/simulator/client';
+import { HashedValuesCache } from '@aztec/simulator/server';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTrees } from '@aztec/world-state';
 
@@ -42,9 +43,7 @@ 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 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,37 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
+  async store(contract: ForeignCallSingle, key: ForeignCallSingle, values: ForeignCallArray) {
+    const processedContract = AztecAddress.fromField(fromSingle(contract));
+    const processedKey = fromSingle(key);
+    const processedValues = fromArray(values);
+    await this.typedOracle.store(processedContract, processedKey, processedValues);
+    return toForeignCallResult([]);
+  }
+
+  /**
+   * Load data from pxe db.
+   * @param contract - The contract address.
+   * @param key - The key to load.
+   * @param tSize - The size of the serialized object to return.
+   * @returns The data found flag and the serialized object concatenated in one array.
+   */
+  async load(contract: ForeignCallSingle, key: ForeignCallSingle, tSize: ForeignCallSingle) {
+    const processedContract = AztecAddress.fromField(fromSingle(contract));
+    const processedKey = fromSingle(key);
+    const values = await this.typedOracle.load(processedContract, processedKey);
+    // 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.
+      const processedTSize = fromSingle(tSize).toNumber();
+      return toForeignCallResult([toSingle(new Fr(0)), toArray(Array(processedTSize).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)]);
+    }
+  }
+
   // 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) {