@aztec/simulator 0.32.1 → 0.34.0

package/src/avm/opcodes/context_getters.ts

@@ -0,0 +1,32 @@
+import type { AvmContext } from '../avm_context.js';
+import { Field, type MemoryValue } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { GetterInstruction } from './instruction_impl.js';
+
+export class L2GasLeft extends GetterInstruction {
+  static type: string = 'L2GASLEFT';
+  static readonly opcode: Opcode = Opcode.L2GASLEFT;
+
+  // TODO(@spalladino) Yellow paper specifies that the value should be an Uint32, not a Field.
+  protected getValue(context: AvmContext): MemoryValue {
+    return new Field(context.machineState.l2GasLeft);
+  }
+}
+
+export class L1GasLeft extends GetterInstruction {
+  static type: string = 'L1GASLEFT';
+  static readonly opcode: Opcode = Opcode.L1GASLEFT;
+
+  protected getValue(context: AvmContext): MemoryValue {
+    return new Field(context.machineState.l1GasLeft);
+  }
+}
+
+export class DAGasLeft extends GetterInstruction {
+  static type: string = 'DAGASLEFT';
+  static readonly opcode: Opcode = Opcode.DAGASLEFT;
+
+  protected getValue(context: AvmContext): MemoryValue {
+    return new Field(context.machineState.daGasLeft);
+  }
+}

package/src/avm/opcodes/contract.ts

@@ -0,0 +1,58 @@
+import { AztecAddress, Fr } from '@aztec/circuits.js';
+
+import type { AvmContext } from '../avm_context.js';
+import { Field } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class GetContractInstance extends Instruction {
+  static readonly type: string = 'GETCONTRACTINSTANCE';
+  static readonly opcode: Opcode = Opcode.GETCONTRACTINSTANCE;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private addressOffset: number, private dstOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const [addressOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.addressOffset, this.dstOffset],
+      context.machineState.memory,
+    );
+
+    const address = AztecAddress.fromField(context.machineState.memory.get(addressOffset).toFr());
+    const instance = await context.persistableState.hostStorage.contractsDb.getContractInstance(address);
+
+    const data =
+      instance === undefined
+        ? [
+            new Field(0), // not found
+            new Field(0),
+            new Field(0),
+            new Field(0),
+            new Field(0),
+            new Field(0),
+            new Field(0),
+          ]
+        : [
+            new Fr(1), // found
+            instance.salt,
+            instance.deployer.toField(),
+            instance.contractClassId,
+            instance.initializationHash,
+            instance.portalContractAddress.toField(),
+            instance.publicKeysHash,
+          ].map(f => new Field(f));
+
+    context.machineState.memory.setSlice(dstOffset, data);
+
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/control_flow.ts

@@ -14,8 +14,12 @@ export class Jump extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
     context.machineState.pc = this.jumpOffset;
+
+    context.machineState.memory.assert({});
   }
 }
 
@@ -35,8 +39,12 @@ export class JumpI extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const condition = context.machineState.memory.getAs<IntegralValue>(this.condOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const condition = memory.getAs<IntegralValue>(this.condOffset);
 
     // TODO: reconsider this casting
     if (condition.toBigInt() == 0n) {
@@ -44,6 +52,8 @@ export class JumpI extends Instruction {
     } else {
       context.machineState.pc = this.loc;
     }
+
+    memory.assert(memoryOperations);
   }
 }
 
@@ -57,9 +67,13 @@ export class InternalCall extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
     context.machineState.internalCallStack.push(context.machineState.pc + 1);
     context.machineState.pc = this.loc;
+
+    context.machineState.memory.assert({});
   }
 }
 
@@ -73,11 +87,15 @@ export class InternalReturn extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
     const jumpOffset = context.machineState.internalCallStack.pop();
     if (jumpOffset === undefined) {
       throw new InstructionExecutionError('Internal call stack empty!');
     }
     context.machineState.pc = jumpOffset;
+
+    context.machineState.memory.assert({});
   }
 }

package/src/avm/opcodes/environment_getters.ts

@@ -2,136 +2,127 @@ import { type Fr } from '@aztec/circuits.js';
 
 import type { AvmContext } from '../avm_context.js';
 import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { Field } from '../avm_memory_types.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Instruction } from './instruction.js';
+import { Field, type MemoryValue } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { GetterInstruction } from './instruction_impl.js';
 
-abstract class GetterInstruction extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
-
-  constructor(protected indirect: number, protected dstOffset: number) {
-    super();
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    const res = new Field(this.getIt(context.environment));
-    context.machineState.memory.set(this.dstOffset, res);
-    context.machineState.incrementPc();
+abstract class EnvironmentGetterInstruction extends GetterInstruction {
+  protected getValue(context: AvmContext): MemoryValue {
+    return new Field(this.getEnvironmentValue(context.environment));
   }
 
-  protected abstract getIt(env: AvmExecutionEnvironment): Fr | number | bigint;
+  protected abstract getEnvironmentValue(env: AvmExecutionEnvironment): Fr | number | bigint;
 }
 
-export class Address extends GetterInstruction {
+export class Address extends EnvironmentGetterInstruction {
   static type: string = 'ADDRESS';
   static readonly opcode: Opcode = Opcode.ADDRESS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.address;
   }
 }
 
-export class StorageAddress extends GetterInstruction {
+export class StorageAddress extends EnvironmentGetterInstruction {
   static type: string = 'STORAGEADDRESS';
   static readonly opcode: Opcode = Opcode.STORAGEADDRESS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.storageAddress;
   }
 }
 
-export class Sender extends GetterInstruction {
+export class Sender extends EnvironmentGetterInstruction {
   static type: string = 'SENDER';
   static readonly opcode: Opcode = Opcode.SENDER;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.sender;
   }
 }
 
-export class Origin extends GetterInstruction {
+export class Origin extends EnvironmentGetterInstruction {
   static type: string = 'ORIGIN';
   static readonly opcode: Opcode = Opcode.ORIGIN;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.origin;
   }
 }
 
-export class FeePerL1Gas extends GetterInstruction {
+export class FeePerL1Gas extends EnvironmentGetterInstruction {
   static type: string = 'FEEPERL1GAS';
   static readonly opcode: Opcode = Opcode.FEEPERL1GAS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.feePerL1Gas;
   }
 }
 
-export class FeePerL2Gas extends GetterInstruction {
+export class FeePerL2Gas extends EnvironmentGetterInstruction {
   static type: string = 'FEEPERL2GAS';
   static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.feePerL2Gas;
   }
 }
 
-export class FeePerDAGas extends GetterInstruction {
+export class FeePerDAGas extends EnvironmentGetterInstruction {
   static type: string = 'FEEPERDAGAS';
   static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.feePerDaGas;
   }
 }
 
-export class Portal extends GetterInstruction {
+export class Portal extends EnvironmentGetterInstruction {
   static type: string = 'PORTAL';
   static readonly opcode: Opcode = Opcode.PORTAL;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.portal.toField();
   }
 }
 
-export class ChainId extends GetterInstruction {
+export class ChainId extends EnvironmentGetterInstruction {
   static type: string = 'CHAINID';
   static readonly opcode: Opcode = Opcode.CHAINID;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.globals.chainId;
   }
 }
 
-export class Version extends GetterInstruction {
+export class Version extends EnvironmentGetterInstruction {
   static type: string = 'VERSION';
   static readonly opcode: Opcode = Opcode.VERSION;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.globals.version;
   }
 }
 
-export class BlockNumber extends GetterInstruction {
+export class BlockNumber extends EnvironmentGetterInstruction {
   static type: string = 'BLOCKNUMBER';
   static readonly opcode: Opcode = Opcode.BLOCKNUMBER;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.globals.blockNumber;
   }
 }
 
-export class Timestamp extends GetterInstruction {
+export class Timestamp extends EnvironmentGetterInstruction {
   static type: string = 'TIMESTAMP';
   static readonly opcode: Opcode = Opcode.TIMESTAMP;
 
-  protected getIt(env: AvmExecutionEnvironment) {
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
     return env.globals.timestamp;
   }
 }
 
-// export class Coinbase extends GetterInstruction {
+// export class Coinbase extends EnvironmentGetterInstruction {
 //     static type: string = 'COINBASE';
 //     static numberOfOperands = 1;
 
@@ -149,7 +140,7 @@ export class Timestamp extends GetterInstruction {
 // }
 
 // // TODO: are these even needed within the block? (both block gas limit variables - why does the execution env care?)
-// export class BlockL1GasLimit extends GetterInstruction {
+// export class BlockL1GasLimit extends EnvironmentGetterInstruction {
 //     static type: string = 'BLOCKL1GASLIMIT';
 //     static numberOfOperands = 1;
 
@@ -166,7 +157,7 @@ export class Timestamp extends GetterInstruction {
 //     }
 // }
 
-// export class BlockL2GasLimit extends GetterInstruction {
+// export class BlockL2GasLimit extends EnvironmentGetterInstruction {
 //     static type: string = 'BLOCKL2GASLIMIT';
 //     static numberOfOperands = 1;
 
@@ -183,7 +174,7 @@ export class Timestamp extends GetterInstruction {
 //     }
 // }
 
-// export class BlockDAGasLimit extends GetterInstruction {
+// export class BlockDAGasLimit extends EnvironmentGetterInstruction {
 //     static type: string = 'BLOCKDAGASLIMIT';
 //     static numberOfOperands = 1;
 

package/src/avm/opcodes/external_calls.ts

@@ -1,15 +1,21 @@
 import { FunctionSelector } from '@aztec/circuits.js';
-
+import { padArrayEnd } from '@aztec/foundation/collection';
+
+import { executePublicFunction } from '../../public/executor.js';
+import {
+  convertPublicExecutionResult,
+  createPublicExecutionContext,
+  updateAvmContextFromPublicExecutionResult,
+} from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
+import { gasLeftToGas, sumGas } from '../avm_gas.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
-import { AvmSimulator } from '../avm_simulator.js';
+import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
-export class Call extends Instruction {
-  static type: string = 'CALL';
-  static readonly opcode: Opcode = Opcode.CALL;
+abstract class ExternalCall extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
@@ -27,7 +33,7 @@ export class Call extends Instruction {
 
   constructor(
     private indirect: number,
-    private _gasOffset: number /* Unused due to no formal gas implementation at this moment */,
+    private gasOffset: number /* Unused due to no formal gas implementation at this moment */,
     private addrOffset: number,
     private argsOffset: number,
     private argsSize: number,
@@ -42,110 +48,95 @@ export class Call extends Instruction {
     super();
   }
 
-  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3992): there is no concept of remaining / available gas at this moment
-  async execute(context: AvmContext): Promise<void> {
-    const [_gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this._gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
-      context.machineState.memory,
+  public async execute(context: AvmContext) {
+    const memory = context.machineState.memory.track(this.type);
+    const [gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
+      memory,
     );
 
-    const callAddress = context.machineState.memory.getAs<Field>(addrOffset);
-    const calldata = context.machineState.memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
-    const functionSelector = context.machineState.memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
+    const callAddress = memory.getAs<Field>(addrOffset);
+    const calldata = memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
+    const l1Gas = memory.get(gasOffset).toNumber();
+    const l2Gas = memory.getAs<Field>(gasOffset + 1).toNumber();
+    const daGas = memory.getAs<Field>(gasOffset + 2).toNumber();
+    const functionSelector = memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
 
+    const allocatedGas = { l1Gas, l2Gas, daGas };
+    const memoryOperations = { reads: this.argsSize + 5, writes: 1 + this.retSize, indirect: this.indirect };
+    const totalGas = sumGas(this.gasCost(memoryOperations), allocatedGas);
+    context.machineState.consumeGas(totalGas);
+
+    // TRANSITIONAL: This should be removed once the AVM is fully operational and the public executor is gone.
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
+      allocatedGas,
+      this.type,
       FunctionSelector.fromField(functionSelector),
     );
+    const pxContext = createPublicExecutionContext(nestedContext, calldata);
+    const pxResults = await executePublicFunction(pxContext, /*nested=*/ true);
+    const nestedCallResults: AvmContractCallResults = convertPublicExecutionResult(pxResults);
+    updateAvmContextFromPublicExecutionResult(nestedContext, pxResults);
+    const nestedPersistableState = nestedContext.persistableState;
+    // const nestedContext = context.createNestedContractCallContext(
+    //   callAddress.toFr(),
+    //   calldata,
+    //   allocatedGas,
+    //   this.type,
+    //   FunctionSelector.fromField(functionSelector),
+    // );
+    // const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
+    // const nestedPersistableState = nestedContext.persistableState;
 
-    const nestedCallResults = await new AvmSimulator(nestedContext).execute();
     const success = !nestedCallResults.reverted;
 
-    // We only take as much data as was specified in the return size -> TODO: should we be reverting here
+    // We only take as much data as was specified in the return size and pad with zeroes if the return data is smaller
+    // than the specified size in order to prevent that memory to be left with garbage
     const returnData = nestedCallResults.output.slice(0, this.retSize);
-    const convertedReturnData = returnData.map(f => new Field(f));
+    const convertedReturnData = padArrayEnd(
+      returnData.map(f => new Field(f)),
+      new Field(0),
+      this.retSize,
+    );
 
     // Write our return data into memory
-    context.machineState.memory.set(successOffset, new Uint8(success ? 1 : 0));
-    context.machineState.memory.setSlice(retOffset, convertedReturnData);
+    memory.set(successOffset, new Uint8(success ? 1 : 0));
+    memory.setSlice(retOffset, convertedReturnData);
 
+    // Refund unused gas
+    context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
+
+    // TODO: Should we merge the changes from a nested call in the case of a STATIC call?
     if (success) {
-      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
+      context.persistableState.acceptNestedCallState(nestedPersistableState);
     } else {
-      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
+      context.persistableState.rejectNestedCallState(nestedPersistableState);
     }
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
+
+  public abstract get type(): 'CALL' | 'STATICCALL';
 }
 
-export class StaticCall extends Instruction {
-  static type: string = 'STATICCALL';
-  static readonly opcode: Opcode = Opcode.STATICCALL;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    /* temporary function selector */
-    OperandType.UINT32,
-  ];
+export class Call extends ExternalCall {
+  static type = 'CALL' as const;
+  static readonly opcode: Opcode = Opcode.CALL;
 
-  constructor(
-    private indirect: number,
-    private _gasOffset: number /* Unused due to no formal gas implementation at this moment */,
-    private addrOffset: number,
-    private argsOffset: number,
-    private argsSize: number,
-    private retOffset: number,
-    private retSize: number,
-    private successOffset: number,
-    private temporaryFunctionSelectorOffset: number,
-  ) {
-    super();
+  public get type() {
+    return Call.type;
   }
+}
 
-  async execute(context: AvmContext): Promise<void> {
-    const [_gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this._gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
-      context.machineState.memory,
-    );
-
-    const callAddress = context.machineState.memory.get(addrOffset);
-    const calldata = context.machineState.memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
-    const functionSelector = context.machineState.memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
-
-    const nestedContext = context.createNestedContractStaticCallContext(
-      callAddress.toFr(),
-      calldata,
-      FunctionSelector.fromField(functionSelector),
-    );
-
-    const nestedCallResults = await new AvmSimulator(nestedContext).execute();
-    const success = !nestedCallResults.reverted;
-
-    // We only take as much data as was specified in the return size -> TODO: should we be reverting here
-    const returnData = nestedCallResults.output.slice(0, this.retSize);
-    const convertedReturnData = returnData.map(f => new Field(f));
-
-    // Write our return data into memory
-    context.machineState.memory.set(successOffset, new Uint8(success ? 1 : 0));
-    context.machineState.memory.setSlice(retOffset, convertedReturnData);
-
-    if (success) {
-      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
-    } else {
-      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
-    }
+export class StaticCall extends ExternalCall {
+  static type = 'STATICCALL' as const;
+  static readonly opcode: Opcode = Opcode.STATICCALL;
 
-    context.machineState.incrementPc();
+  public get type() {
+    return StaticCall.type;
   }
 }
 
@@ -164,12 +155,17 @@ export class Return extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], context.machineState.memory);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.copySize, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], memory);
 
-    const output = context.machineState.memory.getSlice(returnOffset, this.copySize).map(word => word.toFr());
+    const output = memory.getSlice(returnOffset, this.copySize).map(word => word.toFr());
 
     context.machineState.return(output);
+    memory.assert(memoryOperations);
   }
 }
 
@@ -188,11 +184,16 @@ export class Revert extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], context.machineState.memory);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.retSize, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], memory);
 
-    const output = context.machineState.memory.getSlice(returnOffset, this.retSize).map(word => word.toFr());
+    const output = memory.getSlice(returnOffset, this.retSize).map(word => word.toFr());
 
     context.machineState.revert(output);
+    memory.assert(memoryOperations);
   }
 }