@aztec/txe 0.47.1 → 0.49.2

package/src/oracle/txe_oracle.ts

@@ -68,6 +68,7 @@ import {
   toACVMWitness,
   witnessMapToFields,
 } from '@aztec/simulator';
+import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { type ContractInstance, type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { MerkleTreeSnapshotOperationsFacade, type MerkleTrees } from '@aztec/world-state';
 
@@ -103,6 +104,14 @@ export class TXE implements TypedOracle {
 
   // Utils
 
+  async #getTreesAt(blockNumber: number) {
+    const db =
+      blockNumber === (await this.getBlockNumber())
+        ? this.trees.asLatest()
+        : new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+    return db;
+  }
+
   getChainId() {
     return Promise.resolve(this.chainId);
   }
@@ -174,11 +183,16 @@ export class TXE implements TypedOracle {
     isStaticCall = false,
     isDelegateCall = false,
   ) {
-    const trees = this.getTrees();
-    const stateReference = await trees.getStateReference(false);
+    const db = await this.#getTreesAt(blockNumber);
+    const previousBlockState = await this.#getTreesAt(blockNumber - 1);
+
+    const stateReference = await db.getStateReference();
     const inputs = PrivateContextInputs.empty();
     inputs.historicalHeader.globalVariables.blockNumber = new Fr(blockNumber);
     inputs.historicalHeader.state = stateReference;
+    inputs.historicalHeader.lastArchive.root = Fr.fromBuffer(
+      (await previousBlockState.getTreeInfo(MerkleTreeId.ARCHIVE)).root,
+    );
     inputs.callContext.msgSender = this.msgSender;
     inputs.callContext.storageContractAddress = this.contractAddress;
     inputs.callContext.isStaticCall = isStaticCall;
@@ -213,10 +227,10 @@ export class TXE implements TypedOracle {
     return Promise.resolve();
   }
 
-  async avmOpcodeEmitNoteHash(innerNoteHash: Fr) {
+  async avmOpcodeEmitNoteHash(noteHash: Fr) {
     const db = this.trees.asLatest();
-    const noteHash = siloNoteHash(this.contractAddress, innerNoteHash);
-    await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [noteHash]);
+    const siloedNoteHash = siloNoteHash(this.contractAddress, noteHash);
+    await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [siloedNoteHash]);
     return Promise.resolve();
   }
 
@@ -240,9 +254,9 @@ export class TXE implements TypedOracle {
     await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, siloedNullifiers, NULLIFIER_SUBTREE_HEIGHT);
   }
 
-  async addNoteHashes(contractAddress: AztecAddress, innerNoteHashes: Fr[]) {
+  async addNoteHashes(contractAddress: AztecAddress, noteHashes: Fr[]) {
     const db = this.trees.asLatest();
-    const siloedNoteHashes = innerNoteHashes.map(innerNoteHash => siloNoteHash(contractAddress, innerNoteHash));
+    const siloedNoteHashes = noteHashes.map(noteHash => siloNoteHash(contractAddress, noteHash));
     await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, siloedNoteHashes);
   }
 
@@ -284,8 +298,14 @@ export class TXE implements TypedOracle {
     return contractInstance;
   }
 
-  getMembershipWitness(_blockNumber: number, _treeId: MerkleTreeId, _leafValue: Fr): Promise<Fr[] | undefined> {
-    throw new Error('Method not implemented.');
+  async getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined> {
+    const db = await this.#getTreesAt(blockNumber);
+    const index = await db.findLeafIndex(treeId, leafValue.toBuffer());
+    if (!index) {
+      throw new Error(`Leaf value: ${leafValue} not found in ${MerkleTreeId[treeId]} at block ${blockNumber}`);
+    }
+    const siblingPath = await db.getSiblingPath(treeId, index);
+    return [new Fr(index), ...siblingPath.toFields()];
   }
 
   async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr) {
@@ -298,14 +318,14 @@ export class TXE implements TypedOracle {
     blockNumber: number,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
-    const index = await committedDb.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    const db = await this.#getTreesAt(blockNumber);
+    const index = await db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
     if (!index) {
       return undefined;
     }
 
-    const leafPreimagePromise = committedDb.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
-    const siblingPathPromise = committedDb.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(
+    const leafPreimagePromise = db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+    const siblingPathPromise = db.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(
       MerkleTreeId.NULLIFIER_TREE,
       BigInt(index),
     );
@@ -344,8 +364,12 @@ export class TXE implements TypedOracle {
     throw new Error('Method not implemented.');
   }
 
-  getHeader(_blockNumber: number): Promise<Header | undefined> {
-    throw new Error('Method not implemented.');
+  async getHeader(blockNumber: number): Promise<Header | undefined> {
+    const header = Header.empty();
+    const db = await this.#getTreesAt(blockNumber);
+    header.state = await db.getStateReference();
+    header.globalVariables.blockNumber = new Fr(blockNumber);
+    return header;
   }
 
   getCompleteAddress(account: AztecAddress) {
@@ -402,7 +426,7 @@ export class TXE implements TypedOracle {
     return Promise.resolve(notes);
   }
 
-  notifyCreatedNote(storageSlot: Fr, noteTypeId: NoteSelector, noteItems: Fr[], innerNoteHash: Fr, counter: number) {
+  notifyCreatedNote(storageSlot: Fr, noteTypeId: NoteSelector, noteItems: Fr[], noteHash: Fr, counter: number) {
     const note = new Note(noteItems);
     this.noteCache.addNewNote(
       {
@@ -411,15 +435,17 @@ export class TXE implements TypedOracle {
         nonce: Fr.ZERO, // Nonce cannot be known during private execution.
         note,
         siloedNullifier: undefined, // Siloed nullifier cannot be known for newly created note.
-        innerNoteHash,
+        noteHash,
       },
       counter,
     );
+    this.sideEffectsCounter = counter + 1;
     return Promise.resolve();
   }
 
-  notifyNullifiedNote(innerNullifier: Fr, innerNoteHash: Fr, _counter: number) {
-    this.noteCache.nullifyNote(this.contractAddress, innerNullifier, innerNoteHash);
+  notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
+    this.noteCache.nullifyNote(this.contractAddress, innerNullifier, noteHash);
+    this.sideEffectsCounter = counter + 1;
     return Promise.resolve();
   }
 
@@ -468,11 +494,7 @@ export class TXE implements TypedOracle {
     blockNumber: number,
     numberOfElements: number,
   ): Promise<Fr[]> {
-    const db =
-      blockNumber === (await this.getBlockNumber())
-        ? this.trees.asLatest()
-        : new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
-
+    const db = await this.#getTreesAt(blockNumber);
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = startStorageSlot.add(new Fr(i));
@@ -510,11 +532,13 @@ export class TXE implements TypedOracle {
     return publicDataWrites.map(write => write.newValue);
   }
 
-  emitEncryptedLog(_contractAddress: AztecAddress, _randomness: Fr, _encryptedNote: Buffer, _counter: number): void {
+  emitEncryptedLog(_contractAddress: AztecAddress, _randomness: Fr, _encryptedNote: Buffer, counter: number): void {
+    this.sideEffectsCounter = counter + 1;
     return;
   }
 
-  emitEncryptedNoteLog(_noteHashCounter: number, _encryptedNote: Buffer, _counter: number): void {
+  emitEncryptedNoteLog(_noteHashCounter: number, _encryptedNote: Buffer, counter: number): void {
+    this.sideEffectsCounter = counter + 1;
     return;
   }
 
@@ -536,7 +560,8 @@ export class TXE implements TypedOracle {
     return taggedNote.encrypt(ephSk, recipient, ivpkM, ovKeys);
   }
 
-  emitUnencryptedLog(_log: UnencryptedL2Log, _counter: number): void {
+  emitUnencryptedLog(_log: UnencryptedL2Log, counter: number): void {
+    this.sideEffectsCounter = counter + 1;
     return;
   }
 
@@ -609,7 +634,7 @@ export class TXE implements TypedOracle {
 
       // Apply side effects
       const endSideEffectCounter = publicInputs.endSideEffectCounter;
-      this.sideEffectsCounter = endSideEffectCounter.toNumber();
+      this.sideEffectsCounter = endSideEffectCounter.toNumber() + 1;
 
       await this.addNullifiers(
         targetContractAddress,
@@ -676,27 +701,21 @@ export class TXE implements TypedOracle {
     return `${artifact.name}:${f.name}`;
   }
 
-  async executePublicFunction(targetContractAddress: AztecAddress, args: Fr[], callContext: CallContext) {
+  async executePublicFunction(
+    targetContractAddress: AztecAddress,
+    args: Fr[],
+    callContext: CallContext,
+    counter: number,
+  ) {
     const header = Header.empty();
     header.state = await this.trees.getStateReference(true);
     header.globalVariables.blockNumber = new Fr(await this.getBlockNumber());
-    header.state.partial.nullifierTree.root = Fr.fromBuffer(
-      (await this.trees.getTreeInfo(MerkleTreeId.NULLIFIER_TREE, true)).root,
-    );
-    header.state.partial.noteHashTree.root = Fr.fromBuffer(
-      (await this.trees.getTreeInfo(MerkleTreeId.NOTE_HASH_TREE, true)).root,
-    );
-    header.state.partial.publicDataTree.root = Fr.fromBuffer(
-      (await this.trees.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE, true)).root,
-    );
-    header.state.l1ToL2MessageTree.root = Fr.fromBuffer(
-      (await this.trees.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, true)).root,
-    );
     const executor = new PublicExecutor(
       new TXEPublicStateDB(this),
       new ContractsDataSourcePublicDB(new TXEPublicContractDataSource(this)),
       new WorldStateDB(this.trees.asLatest()),
       header,
+      new NoopTelemetryClient(),
     );
     const execution = new PublicExecutionRequest(targetContractAddress, callContext, args);
 
@@ -707,6 +726,7 @@ export class TXE implements TypedOracle {
       TxContext.empty(),
       /* pendingNullifiers */ [],
       /* transactionFee */ Fr.ONE,
+      counter,
     );
   }
 
@@ -732,11 +752,16 @@ export class TXE implements TypedOracle {
     callContext.isStaticCall = isStaticCall;
     callContext.isDelegateCall = isDelegateCall;
 
-    const executionResult = await this.executePublicFunction(targetContractAddress, args, callContext);
+    const executionResult = await this.executePublicFunction(
+      targetContractAddress,
+      args,
+      callContext,
+      this.sideEffectsCounter,
+    );
 
     // Apply side effects
     if (!executionResult.reverted) {
-      this.sideEffectsCounter += executionResult.endSideEffectCounter.toNumber();
+      this.sideEffectsCounter = executionResult.endSideEffectCounter.toNumber() + 1;
     }
     this.setContractAddress(currentContractAddress);
     this.setMsgSender(currentMessageSender);
@@ -745,47 +770,11 @@ export class TXE implements TypedOracle {
     return executionResult;
   }
 
-  async callPublicFunction(
-    targetContractAddress: AztecAddress,
-    functionSelector: FunctionSelector,
-    argsHash: Fr,
-    _sideEffectCounter: number,
-    isStaticCall: boolean,
-    isDelegateCall: boolean,
-  ): Promise<Fr[]> {
-    // Store and modify env
-    const currentContractAddress = AztecAddress.fromField(this.contractAddress);
-    const currentMessageSender = AztecAddress.fromField(this.msgSender);
-    const currentFunctionSelector = FunctionSelector.fromField(this.functionSelector.toField());
-    this.setMsgSender(this.contractAddress);
-    this.setContractAddress(targetContractAddress);
-    this.setFunctionSelector(functionSelector);
-
-    const callContext = CallContext.empty();
-    callContext.msgSender = this.msgSender;
-    callContext.functionSelector = this.functionSelector;
-    callContext.storageContractAddress = targetContractAddress;
-    callContext.isStaticCall = isStaticCall;
-    callContext.isDelegateCall = isDelegateCall;
-
-    const args = this.packedValuesCache.unpack(argsHash);
-
-    const executionResult = await this.executePublicFunction(targetContractAddress, args, callContext);
-
-    // Apply side effects
-    this.sideEffectsCounter = executionResult.endSideEffectCounter.toNumber();
-    this.setContractAddress(currentContractAddress);
-    this.setMsgSender(currentMessageSender);
-    this.setFunctionSelector(currentFunctionSelector);
-
-    return executionResult.returnValues;
-  }
-
   async enqueuePublicFunctionCall(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
-    _sideEffectCounter: number,
+    sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
   ) {
@@ -806,10 +795,19 @@ export class TXE implements TypedOracle {
 
     const args = this.packedValuesCache.unpack(argsHash);
 
-    const executionResult = await this.executePublicFunction(targetContractAddress, args, callContext);
+    const executionResult = await this.executePublicFunction(
+      targetContractAddress,
+      args,
+      callContext,
+      sideEffectCounter,
+    );
+
+    if (executionResult.reverted) {
+      throw new Error(`Execution reverted with reason: ${executionResult.revertReason}`);
+    }
 
     // Apply side effects
-    this.sideEffectsCounter += executionResult.endSideEffectCounter.toNumber();
+    this.sideEffectsCounter = executionResult.endSideEffectCounter.toNumber() + 1;
     this.setContractAddress(currentContractAddress);
     this.setMsgSender(currentMessageSender);
     this.setFunctionSelector(currentFunctionSelector);
@@ -835,6 +833,10 @@ export class TXE implements TypedOracle {
     );
   }
 
+  notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
+    this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
+  }
+
   aes128Encrypt(input: Buffer, initializationVector: Buffer, key: Buffer): Buffer {
     const aes128 = new Aes128();
     return aes128.encryptBufferCBC(input, initializationVector, key);
@@ -848,8 +850,9 @@ export class TXE implements TypedOracle {
     _contractAddress: AztecAddress,
     _randomness: Fr,
     _encryptedEvent: Buffer,
-    _counter: number,
+    counter: number,
   ): void {
+    this.sideEffectsCounter = counter + 1;
     return;
   }
 

package/src/txe_service/txe_service.ts

@@ -40,7 +40,8 @@ export class TXEService {
     const store = openTmpStore(true);
     const trees = await MerkleTrees.new(store, logger);
     const packedValuesCache = new PackedValuesCache();
-    const noteCache = new ExecutionNoteCache();
+    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 keyStore = new KeyStore(store);
     const txeDatabase = new TXEDatabase(store);
     logger.info(`TXE service initialized`);
@@ -66,16 +67,16 @@ export class TXEService {
     const nBlocks = fromSingle(blocks).toNumber();
     this.logger.debug(`time traveling ${nBlocks} blocks`);
     const trees = (this.typedOracle as TXE).getTrees();
-    const header = Header.empty();
-    const l2Block = L2Block.empty();
-    header.state = await trees.getStateReference(true);
-    const blockNumber = await this.typedOracle.getBlockNumber();
-    header.globalVariables.blockNumber = new Fr(blockNumber);
-    l2Block.archive.root = Fr.fromBuffer((await trees.getTreeInfo(MerkleTreeId.ARCHIVE, true)).root);
-    l2Block.header = header;
     for (let i = 0; i < nBlocks; i++) {
       const blockNumber = await this.typedOracle.getBlockNumber();
+      const header = Header.empty();
+      const l2Block = L2Block.empty();
+      header.state = await trees.getStateReference(true);
       header.globalVariables.blockNumber = new Fr(blockNumber);
+      await trees.appendLeaves(MerkleTreeId.ARCHIVE, [header.hash()]);
+      l2Block.archive.root = Fr.fromBuffer((await trees.getTreeInfo(MerkleTreeId.ARCHIVE, true)).root);
+      l2Block.header = header;
+      this.logger.debug(`Block ${blockNumber} created, header hash ${header.hash().toString()}`);
       await trees.handleL2BlockAndMessages(l2Block, []);
       (this.typedOracle as TXE).setBlockNumber(blockNumber + 1);
     }
@@ -442,14 +443,14 @@ export class TXEService {
     storageSlot: ForeignCallSingle,
     noteTypeId: ForeignCallSingle,
     note: ForeignCallArray,
-    innerNoteHash: ForeignCallSingle,
+    noteHash: ForeignCallSingle,
     counter: ForeignCallSingle,
   ) {
     this.typedOracle.notifyCreatedNote(
       fromSingle(storageSlot),
       NoteSelector.fromField(fromSingle(noteTypeId)),
       fromArray(note),
-      fromSingle(innerNoteHash),
+      fromSingle(noteHash),
       fromSingle(counter).toNumber(),
     );
     return toForeignCallResult([toSingle(new Fr(0))]);
@@ -457,12 +458,12 @@ export class TXEService {
 
   async notifyNullifiedNote(
     innerNullifier: ForeignCallSingle,
-    innerNoteHash: ForeignCallSingle,
+    noteHash: ForeignCallSingle,
     counter: ForeignCallSingle,
   ) {
     await this.typedOracle.notifyNullifiedNote(
       fromSingle(innerNullifier),
-      fromSingle(innerNoteHash),
+      fromSingle(noteHash),
       fromSingle(counter).toNumber(),
     );
     return toForeignCallResult([toSingle(new Fr(0))]);
@@ -511,8 +512,8 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
-  async avmOpcodeEmitNoteHash(innerNoteHash: ForeignCallSingle) {
-    await (this.typedOracle as TXE).avmOpcodeEmitNoteHash(fromSingle(innerNoteHash));
+  async avmOpcodeEmitNoteHash(noteHash: ForeignCallSingle) {
+    await (this.typedOracle as TXE).avmOpcodeEmitNoteHash(fromSingle(noteHash));
     return toForeignCallResult([]);
   }
 
@@ -711,6 +712,10 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
+  public notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: ForeignCallSingle) {
+    this.typedOracle.notifySetMinRevertibleSideEffectCounter(fromSingle(minRevertibleSideEffectCounter).toNumber());
+  }
+
   async getChainId() {
     return toForeignCallResult([toSingle(await this.typedOracle.getChainId())]);
   }
@@ -728,4 +733,25 @@ export class TXEService {
     await (this.typedOracle as TXE).addNoteHashes(fromSingle(contractAddress), fromArray(noteHashes));
     return toForeignCallResult([]);
   }
+
+  async getHeader(blockNumber: ForeignCallSingle) {
+    const header = await this.typedOracle.getHeader(fromSingle(blockNumber).toNumber());
+    if (!header) {
+      throw new Error(`Block header not found for block ${blockNumber}.`);
+    }
+    return toForeignCallResult([toArray(header.toFields())]);
+  }
+
+  async getMembershipWitness(blockNumber: ForeignCallSingle, treeId: ForeignCallSingle, leafValue: ForeignCallSingle) {
+    const parsedBlockNumber = fromSingle(blockNumber).toNumber();
+    const parsedTreeId = fromSingle(treeId).toNumber();
+    const parsedLeafValue = fromSingle(leafValue);
+    const witness = await this.typedOracle.getMembershipWitness(parsedBlockNumber, parsedTreeId, parsedLeafValue);
+    if (!witness) {
+      throw new Error(
+        `Membership witness in tree ${MerkleTreeId[parsedTreeId]} not found for value ${parsedLeafValue} at block ${parsedBlockNumber}.`,
+      );
+    }
+    return toForeignCallResult([toArray(witness)]);
+  }
 }