@aztec/pxe 0.0.1-commit.24de95ac → 0.0.1-commit.3469e52

package/src/contract_function_simulator/oracle/oracle.ts

@@ -1,4 +1,6 @@
-import { Fr, Point } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import {
   type ACIRCallback,
   type ACVMField,
@@ -10,11 +12,12 @@ import {
 } from '@aztec/simulator/client';
 import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import { ContractClassLog, ContractClassLogFields } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
 import type { IMiscOracle, IPrivateExecutionOracle, IUtilityExecutionOracle } from './interfaces.js';
-import { packAsRetrievedNote } from './note_packing_utils.js';
+import { packAsHintedNote } from './note_packing_utils.js';
 
 export class UnavailableOracleError extends Error {
   constructor(oracleName: string) {
@@ -100,8 +103,7 @@ export class Oracle {
     return Promise.resolve([toACVMField(val)]);
   }
 
-  // Since the argument is a slice, noir automatically adds a length field to oracle call.
-  privateStoreInExecutionCache(_length: ACVMField[], values: ACVMField[], [hash]: ACVMField[]): Promise<ACVMField[]> {
+  privateStoreInExecutionCache(values: ACVMField[], [hash]: ACVMField[]): Promise<ACVMField[]> {
     this.handlerAsPrivate().privateStoreInExecutionCache(values.map(Fr.fromString), Fr.fromString(hash));
     return Promise.resolve([]);
   }
@@ -111,9 +113,9 @@ export class Oracle {
     return [values.map(toACVMField)];
   }
 
-  async utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
-    const context = await this.handlerAsUtility().utilityGetUtilityContext();
-    return context.toNoirRepresentation();
+  utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
+    const context = this.handlerAsUtility().utilityGetUtilityContext();
+    return Promise.resolve(context.toNoirRepresentation());
   }
 
   async utilityGetKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {
@@ -137,73 +139,77 @@ export class Oracle {
   }
 
   async utilityGetMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [treeId]: ACVMField[],
     [leafValue]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedTreeId = Fr.fromString(treeId).toNumber();
     const parsedLeafValue = Fr.fromString(leafValue);
 
     const witness = await this.handlerAsUtility().utilityGetMembershipWitness(
-      parsedBlockNumber,
+      parsedBlockHash,
       parsedTreeId,
       parsedLeafValue,
     );
     if (!witness) {
       throw new Error(
-        `Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block ${parsedBlockNumber}.`,
+        `Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block hash ${parsedBlockHash.toString()}.`,
       );
     }
     return [toACVMField(witness[0]), witness.slice(1).map(toACVMField)];
   }
 
   async utilityGetNullifierMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the witness for (to prove inclusion)
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedNullifier = Fr.fromString(nullifier);
 
     const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(
-      parsedBlockNumber,
+      parsedBlockHash,
       parsedNullifier,
     );
     if (!witness) {
-      throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`);
+      throw new Error(
+        `Nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`,
+      );
     }
     return witness.toNoirRepresentation();
   }
 
   async utilityGetLowNullifierMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the low nullifier witness for (to prove non-inclusion)
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedNullifier = Fr.fromString(nullifier);
 
     const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(
-      parsedBlockNumber,
+      parsedBlockHash,
       parsedNullifier,
     );
     if (!witness) {
       throw new Error(
-        `Low nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`,
+        `Low nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`,
       );
     }
     return witness.toNoirRepresentation();
   }
 
   async utilityGetPublicDataWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [leafSlot]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedLeafSlot = Fr.fromString(leafSlot);
 
-    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
+    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(parsedBlockHash, parsedLeafSlot);
     if (!witness) {
-      throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
+      throw new Error(
+        `Public data witness not found for slot ${parsedLeafSlot} at block hash ${parsedBlockHash.toString()}.`,
+      );
     }
     return witness.toNoirRepresentation();
   }
@@ -211,7 +217,7 @@ export class Oracle {
   async utilityGetBlockHeader([blockNumber]: ACVMField[]): Promise<ACVMField[]> {
     const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
 
-    const header = await this.handlerAsUtility().utilityGetBlockHeader(parsedBlockNumber);
+    const header = await this.handlerAsUtility().utilityGetBlockHeader(BlockNumber(parsedBlockNumber));
     if (!header) {
       throw new Error(`Block header not found for block ${parsedBlockNumber}.`);
     }
@@ -236,6 +242,8 @@ export class Oracle {
   }
 
   async utilityGetNotes(
+    [ownerSome]: ACVMField[],
+    [ownerValue]: ACVMField[],
     [storageSlot]: ACVMField[],
     [numSelects]: ACVMField[],
     selectByIndexes: ACVMField[],
@@ -251,9 +259,12 @@ export class Oracle {
     [offset]: ACVMField[],
     [status]: ACVMField[],
     [maxNotes]: ACVMField[],
-    [packedRetrievedNoteLength]: ACVMField[],
+    [packedHintedNoteLength]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
+    // Parse Option<AztecAddress>: ownerSome is 0 for None, 1 for Some
+    const owner = Fr.fromString(ownerSome).toNumber() === 1 ? AztecAddress.fromString(ownerValue) : undefined;
     const noteDatas = await this.handlerAsUtility().utilityGetNotes(
+      owner,
       Fr.fromString(storageSlot),
       +numSelects,
       selectByIndexes.map(s => +s),
@@ -270,26 +281,40 @@ export class Oracle {
       +status,
     );
 
-    const returnDataAsArrayOfPackedRetrievedNotes = noteDatas.map(packAsRetrievedNote);
+    const returnDataAsArrayOfPackedHintedNotes = noteDatas.map(noteData =>
+      packAsHintedNote({
+        contractAddress: noteData.contractAddress,
+        owner: noteData.owner,
+        randomness: noteData.randomness,
+        storageSlot: noteData.storageSlot,
+        noteNonce: noteData.noteNonce,
+        isPending: noteData.isPending,
+        note: noteData.note,
+      }),
+    );
 
     // Now we convert each sub-array to an array of ACVMField
-    const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfPackedRetrievedNotes.map(subArray =>
+    const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfPackedHintedNotes.map(subArray =>
       subArray.map(toACVMField),
     );
 
     // At last we convert the array of arrays to a bounded vec of arrays
-    return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedRetrievedNoteLength);
+    return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedHintedNoteLength);
   }
 
   privateNotifyCreatedNote(
+    [owner]: ACVMField[],
     [storageSlot]: ACVMField[],
+    [randomness]: ACVMField[],
     [noteTypeId]: ACVMField[],
     note: ACVMField[],
     [noteHash]: ACVMField[],
     [counter]: ACVMField[],
   ): Promise<ACVMField[]> {
     this.handlerAsPrivate().privateNotifyCreatedNote(
+      AztecAddress.fromString(owner),
       Fr.fromString(storageSlot),
+      Fr.fromString(randomness),
       NoteSelector.fromField(Fr.fromString(noteTypeId)),
       note.map(Fr.fromString),
       Fr.fromString(noteHash),
@@ -335,15 +360,15 @@ export class Oracle {
   }
 
   async utilityStorageRead(
+    [blockHash]: ACVMField[],
     [contractAddress]: ACVMField[],
     [startStorageSlot]: ACVMField[],
-    [blockNumber]: ACVMField[],
     [numberOfElements]: ACVMField[],
   ): Promise<ACVMField[][]> {
     const values = await this.handlerAsUtility().utilityStorageRead(
+      L2BlockHash.fromString(blockHash),
       new AztecAddress(Fr.fromString(contractAddress)),
       Fr.fromString(startStorageSlot),
-      +blockNumber,
       +numberOfElements,
     );
     return [values.map(toACVMField)];
@@ -433,6 +458,13 @@ export class Oracle {
     return Promise.resolve([]);
   }
 
+  async privateIsSideEffectCounterRevertible([sideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
+    const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(
+      Fr.fromString(sideEffectCounter).toNumber(),
+    );
+    return Promise.resolve([toACVMField(isRevertible)]);
+  }
+
   async privateGetNextAppTagAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
     const tag = await this.handlerAsPrivate().privateGetNextAppTagAsSender(
       AztecAddress.fromString(sender),

package/src/contract_function_simulator/oracle/private_execution.ts

@@ -1,5 +1,5 @@
 import { PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
@@ -18,15 +18,15 @@ import {
   countArgumentsSize,
 } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import type { ContractInstance } from '@aztec/stdlib/contract';
 import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 import { BlockHeader, PrivateCallExecutionResult } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 
-import type { ExecutionDataProvider } from '../execution_data_provider.js';
+import { ContractStore } from '../../storage/contract_store/index.js';
 import { Oracle } from './oracle.js';
 import type { PrivateExecutionOracle } from './private_execution_oracle.js';
 
@@ -84,7 +84,6 @@ export async function executePrivateFunction(
 
   const rawReturnValues = await privateExecutionOracle.privateLoadFromExecutionCache(publicInputs.returnsHash);
 
-  const noteHashLeafIndexMap = privateExecutionOracle.getNoteHashLeafIndexMap();
   const newNotes = privateExecutionOracle.getNewNotes();
   const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
   const offchainEffects = privateExecutionOracle.getOffchainEffects();
@@ -107,7 +106,6 @@ export async function executePrivateFunction(
     Buffer.from(artifact.verificationKey!, 'base64'),
     partialWitness,
     publicInputs,
-    noteHashLeafIndexMap,
     newNotes,
     noteHashNullifierCounterMap,
     rawReturnValues,
@@ -153,21 +151,22 @@ export function extractPrivateCircuitPublicInputs(
  * from the instance is used.
  * @param contractAddress - The address of the contract to read the class id for.
  * @param instance - The instance of the contract.
- * @param executionDataProvider - The execution data provider.
- * @param blockNumber - The block number at which to load the DelayedPublicMutable storing the class id.
- * @param timestamp - The timestamp at which to obtain the class id from the DelayedPublicMutable.
+ * @param aztecNode - The Aztec node to query for storage.
+ * @param header - The header of the block at which to load the DelayedPublicMutable storing the class id.
  * @returns The current class id.
  */
 export async function readCurrentClassId(
   contractAddress: AztecAddress,
   instance: ContractInstance,
-  executionDataProvider: ExecutionDataProvider | AztecNode,
-  blockNumber: number,
-  timestamp: UInt64,
+  aztecNode: AztecNode,
+  header: BlockHeader,
 ) {
+  const blockHashFr = await header.hash();
+  const blockHash = L2BlockHash.fromField(blockHashFr);
+  const timestamp = header.globalVariables.timestamp;
   const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
   const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, slot =>
-    executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceRegistry, slot),
+    aztecNode.getPublicStorageAt(blockHash, ProtocolContractAddress.ContractInstanceRegistry, slot),
   );
   let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
   if (currentClassId.isZero()) {
@@ -177,28 +176,22 @@ export async function readCurrentClassId(
 }
 
 /**
- * Verify that the current class id of a contract obtained from AztecNode is the same as the one in the execution data
- * provider (i.e. PXE).
- * @param contractAddress - The address of the contract to verify class id for.
- * @param executionDataProvider - The execution data provider.
- * @param header - The header of the block at which to verify the current class id. If not provided, the anchor block
- * header of the execution data provider is used.
+ * Verify that the current class id of a contract obtained from AztecNode is the same as the one in contract data
+ * provider (i.e. PXE's own storage).
+ * @param header - The header of the block at which to verify the current class id.
  */
 export async function verifyCurrentClassId(
   contractAddress: AztecAddress,
-  executionDataProvider: ExecutionDataProvider,
-  header?: BlockHeader,
+  aztecNode: AztecNode,
+  contractStore: ContractStore,
+  header: BlockHeader,
 ) {
-  header = header ?? (await executionDataProvider.getAnchorBlockHeader());
+  const instance = await contractStore.getContractInstance(contractAddress);
+  if (!instance) {
+    throw new Error(`No contract instance found for address ${contractAddress.toString()}`);
+  }
 
-  const instance = await executionDataProvider.getContractInstance(contractAddress);
-  const currentClassId = await readCurrentClassId(
-    contractAddress,
-    instance,
-    executionDataProvider,
-    header.globalVariables.blockNumber,
-    header.globalVariables.timestamp,
-  );
+  const currentClassId = await readCurrentClassId(contractAddress, instance, aztecNode, header);
   if (!instance.currentContractClassId.equals(currentClassId)) {
     throw new Error(
       `Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`,