@aztec/simulator 0.27.1 → 0.28.0

package/src/acvm/oracle/typed_oracle.ts

@@ -69,6 +69,12 @@ export class MessageLoadOracleInputs<N extends number> {
   }
 }
 
+class OracleMethodNotAvailableError extends Error {
+  constructor(methodName: string) {
+    super(`Oracle method ${methodName} is not available.`);
+  }
+}
+
 /**
  * Oracle with typed parameters and typed return values.
  * Methods that require read and/or write will have to be implemented based on the context (public, private, or view)
@@ -80,58 +86,58 @@ export abstract class TypedOracle {
   }
 
   packArguments(_args: Fr[]): Promise<Fr> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('packArguments');
   }
 
   getNullifierKeyPair(_accountAddress: AztecAddress): Promise<KeyPair> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getNullifierKeyPair');
   }
 
   getPublicKeyAndPartialAddress(_address: AztecAddress): Promise<Fr[] | undefined> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getPublicKeyAndPartialAddress');
   }
 
   getContractInstance(_address: AztecAddress): Promise<ContractInstance> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getContractInstance');
   }
 
   getMembershipWitness(_blockNumber: number, _treeId: MerkleTreeId, _leafValue: Fr): Promise<Fr[] | undefined> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getMembershipWitness');
   }
 
   getSiblingPath(_blockNumber: number, _treeId: MerkleTreeId, _leafIndex: Fr): Promise<Fr[]> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getSiblingPath');
   }
 
   getNullifierMembershipWitness(_blockNumber: number, _nullifier: Fr): Promise<NullifierMembershipWitness | undefined> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getNullifierMembershipWitness');
   }
 
   getPublicDataTreeWitness(_blockNumber: number, _leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getPublicDataTreeWitness');
   }
 
   getLowNullifierMembershipWitness(
     _blockNumber: number,
     _nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getLowNullifierMembershipWitness');
   }
 
   getHeader(_blockNumber: number): Promise<Header | undefined> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getHeader');
   }
 
   getCompleteAddress(_address: AztecAddress): Promise<CompleteAddress> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getCompleteAddress');
   }
 
   getAuthWitness(_messageHash: Fr): Promise<Fr[] | undefined> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getAuthWitness');
   }
 
   popCapsule(): Promise<Fr[]> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('popCapsule');
   }
 
   getNotes(
@@ -146,35 +152,35 @@ export abstract class TypedOracle {
     _offset: number,
     _status: NoteStatus,
   ): Promise<NoteData[]> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getNotes');
   }
 
   notifyCreatedNote(_storageSlot: Fr, _noteTypeId: Fr, _note: Fr[], _innerNoteHash: Fr): void {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('notifyCreatedNote');
   }
 
   notifyNullifiedNote(_innerNullifier: Fr, _innerNoteHash: Fr): Promise<void> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('notifyNullifiedNote');
   }
 
   checkNullifierExists(_innerNullifier: Fr): Promise<boolean> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('checkNullifierExists');
   }
 
   getL1ToL2MembershipWitness(_entryKey: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getL1ToL2MembershipWitness');
   }
 
   getPortalContractAddress(_contractAddress: AztecAddress): Promise<EthAddress> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('getPortalContractAddress');
   }
 
   storageRead(_startStorageSlot: Fr, _numberOfElements: number): Promise<Fr[]> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('storageRead');
   }
 
   storageWrite(_startStorageSlot: Fr, _values: Fr[]): Promise<Fr[]> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('storageWrite');
   }
 
   emitEncryptedLog(
@@ -184,42 +190,43 @@ export abstract class TypedOracle {
     _publicKey: PublicKey,
     _log: Fr[],
   ): void {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('emitEncryptedLog');
   }
 
   emitUnencryptedLog(_log: UnencryptedL2Log): void {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('emitUnencryptedLog');
   }
 
   callPrivateFunction(
     _targetContractAddress: AztecAddress,
     _functionSelector: FunctionSelector,
     _argsHash: Fr,
-    _sideffectCounter: number,
+    _sideEffectCounter: number,
     _isStaticCall: boolean,
     _isDelegateCall: boolean,
   ): Promise<PrivateCallStackItem> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('callPrivateFunction');
   }
 
   callPublicFunction(
     _targetContractAddress: AztecAddress,
     _functionSelector: FunctionSelector,
     _argsHash: Fr,
+    _sideEffectCounter: number,
     _isStaticCall: boolean,
     _isDelegateCall: boolean,
   ): Promise<Fr[]> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('callPublicFunction');
   }
 
   enqueuePublicFunctionCall(
     _targetContractAddress: AztecAddress,
     _functionSelector: FunctionSelector,
     _argsHash: Fr,
-    _sideffectCounter: number,
+    _sideEffectCounter: number,
     _isStaticCall: boolean,
     _isDelegateCall: boolean,
   ): Promise<PublicCallRequest> {
-    throw new Error('Not available.');
+    throw new OracleMethodNotAvailableError('enqueuePublicFunctionCall');
   }
 }

package/src/avm/avm_memory_types.ts

@@ -160,7 +160,13 @@ export class Field extends MemoryValue {
     return new Field(this.rep.mul(rhs.rep));
   }
 
+  // Euclidean division.
   public div(rhs: Field): Field {
+    return new Field(this.rep.ediv(rhs.rep));
+  }
+
+  // Field division.
+  public fdiv(rhs: Field): Field {
     return new Field(this.rep.div(rhs.rep));
   }
 

package/src/avm/opcodes/arithmetic.ts

@@ -1,5 +1,7 @@
 import type { AvmContext } from '../avm_context.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
 export class Add extends ThreeOperandInstruction {
@@ -79,3 +81,33 @@ export class Div extends ThreeOperandInstruction {
     context.machineState.incrementPc();
   }
 }
+
+export class FieldDiv extends Instruction {
+  static type: string = 'FDIV';
+  static readonly opcode = Opcode.FDIV;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private aOffset: number, private bOffset: number, private dstOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(TypeTag.FIELD, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.getAs<Field>(this.aOffset);
+    const b = context.machineState.memory.getAs<Field>(this.bOffset);
+
+    const dest = a.fdiv(b);
+    context.machineState.memory.set(this.dstOffset, dest);
+
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/serialization/bytecode_serialization.ts

@@ -17,6 +17,7 @@ import {
   FeePerDAGas,
   FeePerL1Gas,
   FeePerL2Gas,
+  FieldDiv,
   InternalCall,
   InternalReturn,
   Jump,
@@ -66,6 +67,7 @@ const INSTRUCTION_SET = () =>
     [Sub.opcode, Sub],
     [Mul.opcode, Mul],
     [Div.opcode, Div],
+    [FieldDiv.opcode, FieldDiv],
     [Eq.opcode, Eq],
     [Lt.opcode, Lt],
     [Lte.opcode, Lte],

package/src/avm/serialization/instruction_serialization.ts

@@ -12,6 +12,7 @@ export enum Opcode {
   SUB,
   MUL,
   DIV,
+  FDIV,
   EQ,
   LT,
   LTE,

package/src/avm/temporary_executor_migration.ts

@@ -98,6 +98,9 @@ export function temporaryConvertAvmResults(
   const newNullifiers: SideEffectLinkedToNoteHash[] = [];
   const unencryptedLogs = FunctionL2Logs.empty();
   const newL2ToL1Messages = newWorldState.newL1Messages.map(() => L2ToL1Message.empty());
+  // TODO keep track of side effect counters
+  const startSideEffectCounter = Fr.ZERO;
+  const endSideEffectCounter = Fr.ZERO;
 
   return {
     execution,
@@ -105,6 +108,8 @@ export function temporaryConvertAvmResults(
     nullifierNonExistentReadRequests,
     newNoteHashes,
     newL2ToL1Messages,
+    startSideEffectCounter,
+    endSideEffectCounter,
     newNullifiers,
     contractStorageReads,
     contractStorageUpdateRequests,

package/src/client/client_execution_context.ts

@@ -75,6 +75,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     protected readonly db: DBOracle,
     private readonly curve: Grumpkin,
     private node: AztecNode,
+    protected sideEffectCounter: number = 0,
     protected log = createDebugLogger('aztec:simulator:client_execution_context'),
   ) {
     super(contractAddress, authWitnesses, db, node, log);
@@ -103,6 +104,8 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.txContext.chainId,
       this.txContext.version,
 
+      new Fr(this.sideEffectCounter),
+
       ...args,
     ];
 
@@ -366,6 +369,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.db,
       this.curve,
       this.node,
+      sideEffectCounter,
     );
 
     const childExecutionResult = await executePrivateFunction(

package/src/client/execution_result.ts

@@ -85,5 +85,5 @@ export function collectEnqueuedPublicFunctionCalls(execResult: ExecutionResult):
   return [
     ...execResult.enqueuedPublicFunctionCalls,
     ...[...execResult.nestedExecutions].flatMap(collectEnqueuedPublicFunctionCalls),
-  ].sort((a, b) => b.callContext.startSideEffectCounter - a.callContext.startSideEffectCounter);
+  ].sort((a, b) => b.callContext.sideEffectCounter - a.callContext.sideEffectCounter);
 }

package/src/client/simulator.ts

@@ -85,6 +85,10 @@ export class AcirSimulator {
     const curve = new Grumpkin();
 
     const header = await this.db.getHeader();
+
+    // reserve the first side effect for the tx hash (inserted by the private kernel)
+    const startSideEffectCounter = 1;
+
     const callContext = new CallContext(
       msgSender,
       contractAddress,
@@ -92,9 +96,7 @@ export class AcirSimulator {
       FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
       false,
       false,
-      // TODO: when contract deployment is done in-app, we should only reserve one counter for the tx hash
-      // 2 counters are reserved for tx hash and contract deployment nullifier
-      1,
+      startSideEffectCounter,
     );
     const context = new ClientExecutionContext(
       contractAddress,
@@ -108,6 +110,7 @@ export class AcirSimulator {
       this.db,
       curve,
       this.node,
+      startSideEffectCounter,
     );
 
     try {

package/src/common/side_effect_counter.ts

@@ -4,6 +4,11 @@
 export class SideEffectCounter {
   constructor(private value = 0) {}
 
+  // TODO(alexg) remove this once public side effect counters is fully accounted for on Noir side
+  current() {
+    return this.value;
+  }
+
   count() {
     const value = this.value;
     this.value++;

package/src/public/db.ts

@@ -2,6 +2,7 @@ import { NullifierMembershipWitness } from '@aztec/circuit-types';
 import { EthAddress, FunctionSelector, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 import { MessageLoadOracleInputs } from '../acvm/index.js';
 
@@ -27,16 +28,25 @@ export interface PublicStateDB {
   storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
 
   /**
-   * Commit the pending changes to the DB.
-   * @returns Nothing.
+   * Mark the uncommitted changes in this TX as a checkpoint.
+   */
+  checkpoint(): Promise<void>;
+
+  /**
+   * Rollback to the last checkpoint.
+   */
+  rollbackToCheckpoint(): Promise<void>;
+
+  /**
+   * Commit the changes in this TX. Includes all changes since the last commit,
+   * even if they haven't been covered by a checkpoint.
    */
   commit(): Promise<void>;
 
   /**
-   * Rollback the pending changes.
-   * @returns Nothing.
+   * Rollback to the last commit.
    */
-  rollback(): Promise<void>;
+  rollbackToCommit(): Promise<void>;
 }
 
 /**
@@ -65,6 +75,13 @@ export interface PublicContractsDB {
    * @returns The portal contract address or undefined if not found.
    */
   getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined>;
+
+  /**
+   * Returns a publicly deployed contract instance.
+   * @param address - Address of the contract.
+   * @returns The contract instance or undefined if not found.
+   */
+  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
 }
 
 /** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */

package/src/public/execution.ts

@@ -26,6 +26,10 @@ export interface PublicExecutionResult {
   newNoteHashes: SideEffect[];
   /** The new l2 to l1 messages generated in this call. */
   newL2ToL1Messages: L2ToL1Message[];
+  /** The side effect counter at the start of the function call. */
+  startSideEffectCounter: Fr;
+  /** The side effect counter after executing this function call */
+  endSideEffectCounter: Fr;
   /** The new nullifiers to be inserted into the nullifier tree. */
   newNullifiers: SideEffectLinkedToNoteHash[];
   /** The nullifier read requests emitted in this call. */

package/src/public/executor.ts

@@ -1,5 +1,5 @@
 import { FunctionL2Logs } from '@aztec/circuit-types';
-import { GlobalVariables, Header, PublicCircuitPublicInputs } from '@aztec/circuits.js';
+import { Fr, GlobalVariables, Header, PublicCircuitPublicInputs } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { spawn } from 'child_process';
@@ -83,6 +83,9 @@ export async function executePublicFunction(
       returnValues: [],
       newNoteHashes: [],
       newL2ToL1Messages: [],
+      // TODO (side effects) get these values in the revert case from the vm
+      startSideEffectCounter: Fr.ZERO,
+      endSideEffectCounter: Fr.ZERO,
       newNullifiers: [],
       nullifierReadRequests: [],
       nullifierNonExistentReadRequests: [],
@@ -107,6 +110,8 @@ export async function executePublicFunction(
     newL2ToL1Msgs,
     newNoteHashes: newNoteHashesPadded,
     newNullifiers: newNullifiersPadded,
+    startSideEffectCounter,
+    endSideEffectCounter,
   } = PublicCircuitPublicInputs.fromFields(returnWitness);
 
   const nullifierReadRequests = nullifierReadRequestsPadded.filter(v => !v.isEmpty());
@@ -136,6 +141,8 @@ export async function executePublicFunction(
     newNoteHashes,
     newL2ToL1Messages,
     newNullifiers,
+    startSideEffectCounter,
+    endSideEffectCounter,
     nullifierReadRequests,
     nullifierNonExistentReadRequests,
     contractStorageReads,
@@ -165,7 +172,11 @@ export class PublicExecutor {
    * @param globalVariables - The global variables to use.
    * @returns The result of the run plus all nested runs.
    */
-  public async simulate(execution: PublicExecution, globalVariables: GlobalVariables): Promise<PublicExecutionResult> {
+  public async simulate(
+    execution: PublicExecution,
+    globalVariables: GlobalVariables,
+    sideEffectCounter: number = 0,
+  ): Promise<PublicExecutionResult> {
     const selector = execution.functionData.selector;
     const acir = await this.contractsDb.getBytecode(execution.contractAddress, selector);
     if (!acir) {
@@ -176,14 +187,12 @@ export class PublicExecutor {
     // We use this cache to hold the packed arguments.
     const packedArgs = PackedArgsCache.create([]);
 
-    const sideEffectCounter = new SideEffectCounter();
-
     const context = new PublicExecutionContext(
       execution,
       this.header,
       globalVariables,
       packedArgs,
-      sideEffectCounter,
+      new SideEffectCounter(sideEffectCounter),
       this.stateDb,
       this.contractsDb,
       this.commitmentsDb,
@@ -213,9 +222,10 @@ export class PublicExecutor {
   public async simulateAvm(
     execution: PublicExecution,
     globalVariables: GlobalVariables,
+    _sideEffectCounter = 0,
   ): Promise<PublicExecutionResult> {
     // Temporary code to construct the AVM context
-    // These data structures will permiate across the simulator when the public executor is phased out
+    // These data structures will permeate across the simulator when the public executor is phased out
     const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
     const worldStateJournal = new AvmPersistableStateManager(hostStorage);
     const executionEnv = temporaryCreateAvmExecutionEnvironment(execution, globalVariables);
@@ -244,8 +254,6 @@ export class PublicExecutor {
    */
   public async getAvmProof(avmExecution: PublicExecution): Promise<Buffer[]> {
     // The paths for the barretenberg binary and the write path are hardcoded for now.
-    // We additionally need the path to a valid crs for proof generation.
-    // const bbPath = '../../barretenberg/cpp';
     const bbPath = path.resolve('../../barretenberg/cpp');
     const artifactsPath = path.resolve('target');
 
@@ -273,8 +281,6 @@ export class PublicExecutor {
       bytecodePath,
       '-d',
       calldataPath,
-      '-c',
-      path.join(bbPath, 'srs_db', 'ignition'),
       '-o',
       proofPath,
     ]);

package/src/public/public_execution_context.ts

@@ -4,6 +4,7 @@ import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { ContractInstance } from '@aztec/types/contracts';
 
 import { TypedOracle, toACVMWitness } from '../acvm/index.js';
 import { PackedArgsCache, SideEffectCounter } from '../common/index.js';
@@ -49,7 +50,13 @@ export class PublicExecutionContext extends TypedOracle {
    */
   public getInitialWitness(witnessStartIndex = 0) {
     const { callContext, args } = this.execution;
-    const fields = [...callContext.toFields(), ...this.header.toFields(), ...this.globalVariables.toFields(), ...args];
+    const fields = [
+      ...callContext.toFields(),
+      ...this.header.toFields(),
+      ...this.globalVariables.toFields(),
+      new Fr(this.sideEffectCounter.current()),
+      ...args,
+    ];
 
     return toACVMWitness(witnessStartIndex, fields);
   }
@@ -160,6 +167,7 @@ export class PublicExecutionContext extends TypedOracle {
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
+    sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
   ) {
@@ -188,7 +196,7 @@ export class PublicExecutionContext extends TypedOracle {
       functionSelector,
       isDelegateCall,
       isStaticCall,
-      startSideEffectCounter: 0, // TODO use counters in public execution
+      sideEffectCounter,
     });
 
     const nestedExecution: PublicExecution = {
@@ -237,4 +245,17 @@ export class PublicExecutionContext extends TypedOracle {
     }
     return await this.commitmentsDb.getNullifierMembershipWitnessAtLatestBlock(nullifier);
   }
+
+  public async getContractInstance(address: AztecAddress): Promise<ContractInstance> {
+    // Note to AVM implementor: The wrapper of the oracle call get_contract_instance in aztec-nr
+    // automatically checks that the returned instance is correct, by hashing it together back
+    // into the address. However, in the AVM, we also need to prove the negative, otherwise a malicious
+    // sequencer could just lie about not having the instance available in its local db. We can do this
+    // by using the prove_contract_non_deployment_at method if the contract is not found in the db.
+    const instance = await this.contractsDb.getContractInstance(address);
+    if (!instance) {
+      throw new Error(`Contract instance at ${address} not found`);
+    }
+    return instance;
+  }
 }