@aztec/simulator 0.23.0 → 0.26.1

package/src/avm/opcodes/bitwise.ts

@@ -0,0 +1,129 @@
+import type { AvmContext } from '../avm_context.js';
+import { IntegralValue } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { ThreeOperandInstruction, TwoOperandInstruction } from './instruction_impl.js';
+
+export class And extends ThreeOperandInstruction {
+  static readonly type: string = 'AND';
+  static readonly opcode = Opcode.AND;
+
+  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
+    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+
+    const res = a.and(b);
+    context.machineState.memory.set(this.dstOffset, res);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Or extends ThreeOperandInstruction {
+  static readonly type: string = 'OR';
+  static readonly opcode = Opcode.OR;
+
+  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
+    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+
+    const res = a.or(b);
+    context.machineState.memory.set(this.dstOffset, res);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Xor extends ThreeOperandInstruction {
+  static readonly type: string = 'XOR';
+  static readonly opcode = Opcode.XOR;
+
+  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
+    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+
+    const res = a.xor(b);
+    context.machineState.memory.set(this.dstOffset, res);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Not extends TwoOperandInstruction {
+  static readonly type: string = 'NOT';
+  static readonly opcode = Opcode.NOT;
+
+  constructor(indirect: number, inTag: number, aOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset);
+
+    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
+
+    const res = a.not();
+    context.machineState.memory.set(this.dstOffset, res);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Shl extends ThreeOperandInstruction {
+  static readonly type: string = 'SHL';
+  static readonly opcode = Opcode.SHL;
+
+  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
+    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+
+    const res = a.shl(b);
+    context.machineState.memory.set(this.dstOffset, res);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Shr extends ThreeOperandInstruction {
+  static readonly type: string = 'SHR';
+  static readonly opcode = Opcode.SHR;
+
+  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
+    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+
+    const res = a.shr(b);
+    context.machineState.memory.set(this.dstOffset, res);
+
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/comparators.ts

@@ -0,0 +1,69 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+
+export class Eq extends ThreeOperandInstruction {
+  static readonly type: string = 'EQ';
+  static readonly opcode = Opcode.EQ;
+
+  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.get(this.aOffset);
+    const b = context.machineState.memory.get(this.bOffset);
+
+    // Result will be of the same type as 'a'.
+    const dest = a.build(a.equals(b) ? 1n : 0n);
+    context.machineState.memory.set(this.dstOffset, dest);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Lt extends ThreeOperandInstruction {
+  static readonly type: string = 'LT';
+  static readonly opcode = Opcode.LT;
+
+  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.get(this.aOffset);
+    const b = context.machineState.memory.get(this.bOffset);
+
+    // Result will be of the same type as 'a'.
+    const dest = a.build(a.lt(b) ? 1n : 0n);
+    context.machineState.memory.set(this.dstOffset, dest);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Lte extends ThreeOperandInstruction {
+  static readonly type: string = 'LTE';
+  static readonly opcode = Opcode.LTE;
+
+  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
+    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = context.machineState.memory.get(this.aOffset);
+    const b = context.machineState.memory.get(this.bOffset);
+
+    // Result will be of the same type as 'a'.
+    const dest = a.build(a.equals(b) || a.lt(b) ? 1n : 0n);
+    context.machineState.memory.set(this.dstOffset, dest);
+
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/control_flow.ts

@@ -0,0 +1,129 @@
+import type { AvmContext } from '../avm_context.js';
+import { IntegralValue } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+
+export class Return extends Instruction {
+  static type: string = 'RETURN';
+  static readonly opcode: Opcode = Opcode.RETURN;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private returnOffset: number, private copySize: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const output = context.machineState.memory.getSlice(this.returnOffset, this.copySize).map(word => word.toFr());
+
+    context.machineState.return(output);
+  }
+}
+
+export class Revert extends Instruction {
+  static type: string = 'RETURN';
+  static readonly opcode: Opcode = Opcode.REVERT;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private returnOffset: number, private retSize: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const output = context.machineState.memory
+      .getSlice(this.returnOffset, this.returnOffset + this.retSize)
+      .map(word => word.toFr());
+
+    context.machineState.revert(output);
+  }
+}
+
+export class Jump extends Instruction {
+  static type: string = 'JUMP';
+  static readonly opcode: Opcode = Opcode.JUMP;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
+
+  constructor(private jumpOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.pc = this.jumpOffset;
+  }
+}
+
+export class JumpI extends Instruction {
+  static type: string = 'JUMPI';
+  static readonly opcode: Opcode = Opcode.JUMPI;
+
+  // Instruction wire format with opcode.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private loc: number, private condOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const condition = context.machineState.memory.getAs<IntegralValue>(this.condOffset);
+
+    // TODO: reconsider this casting
+    if (condition.toBigInt() == 0n) {
+      context.machineState.incrementPc();
+    } else {
+      context.machineState.pc = this.loc;
+    }
+  }
+}
+
+export class InternalCall extends Instruction {
+  static readonly type: string = 'INTERNALCALL';
+  static readonly opcode: Opcode = Opcode.INTERNALCALL;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
+
+  constructor(private loc: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    context.machineState.internalCallStack.push(context.machineState.pc + 1);
+    context.machineState.pc = this.loc;
+  }
+}
+
+export class InternalReturn extends Instruction {
+  static readonly type: string = 'INTERNALRETURN';
+  static readonly opcode: Opcode = Opcode.INTERNALRETURN;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8];
+
+  constructor() {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const jumpOffset = context.machineState.internalCallStack.pop();
+    if (jumpOffset === undefined) {
+      throw new InstructionExecutionError('Internal call empty!');
+    }
+    context.machineState.pc = jumpOffset;
+  }
+}

package/src/avm/opcodes/environment_getters.ts

@@ -0,0 +1,201 @@
+import { 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';
+
+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();
+  }
+
+  protected abstract getIt(env: AvmExecutionEnvironment): Fr | number | bigint;
+}
+
+export class Address extends GetterInstruction {
+  static type: string = 'ADDRESS';
+  static readonly opcode: Opcode = Opcode.ADDRESS;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.address;
+  }
+}
+
+export class StorageAddress extends GetterInstruction {
+  static type: string = 'STORAGEADDRESS';
+  static readonly opcode: Opcode = Opcode.STORAGEADDRESS;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.storageAddress;
+  }
+}
+
+export class Sender extends GetterInstruction {
+  static type: string = 'SENDER';
+  static readonly opcode: Opcode = Opcode.SENDER;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.sender;
+  }
+}
+
+export class Origin extends GetterInstruction {
+  static type: string = 'ORIGIN';
+  static readonly opcode: Opcode = Opcode.ORIGIN;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.origin;
+  }
+}
+
+export class FeePerL1Gas extends GetterInstruction {
+  static type: string = 'FEEPERL1GAS';
+  static readonly opcode: Opcode = Opcode.FEEPERL1GAS;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.feePerL1Gas;
+  }
+}
+
+export class FeePerL2Gas extends GetterInstruction {
+  static type: string = 'FEEPERL2GAS';
+  static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.feePerL2Gas;
+  }
+}
+
+export class FeePerDAGas extends GetterInstruction {
+  static type: string = 'FEEPERDAGAS';
+  static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.feePerDaGas;
+  }
+}
+
+export class Portal extends GetterInstruction {
+  static type: string = 'PORTAL';
+  static readonly opcode: Opcode = Opcode.PORTAL;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.portal.toField();
+  }
+}
+
+export class ChainId extends GetterInstruction {
+  static type: string = 'CHAINID';
+  static readonly opcode: Opcode = Opcode.CHAINID;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.globals.chainId;
+  }
+}
+
+export class Version extends GetterInstruction {
+  static type: string = 'VERSION';
+  static readonly opcode: Opcode = Opcode.VERSION;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.globals.version;
+  }
+}
+
+export class BlockNumber extends GetterInstruction {
+  static type: string = 'BLOCKNUMBER';
+  static readonly opcode: Opcode = Opcode.BLOCKNUMBER;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.globals.blockNumber;
+  }
+}
+
+export class Timestamp extends GetterInstruction {
+  static type: string = 'TIMESTAMP';
+  static readonly opcode: Opcode = Opcode.TIMESTAMP;
+
+  protected getIt(env: AvmExecutionEnvironment) {
+    return env.globals.timestamp;
+  }
+}
+
+// export class Coinbase extends GetterInstruction {
+//     static type: string = 'COINBASE';
+//     static numberOfOperands = 1;
+
+//     constructor(private destOffset: number) {
+//         super();
+//     }
+
+//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
+//         const {coinbase} = machineState.executionEnvironment.globals;
+
+//         machineState.memory.set(this.destOffset, coinbase);
+
+//         this.incrementPc(machineState);
+//     }
+// }
+
+// // TODO: are these even needed within the block? (both block gas limit variables - why does the execution env care?)
+// export class BlockL1GasLimit extends GetterInstruction {
+//     static type: string = 'BLOCKL1GASLIMIT';
+//     static numberOfOperands = 1;
+
+//     constructor(private destOffset: number) {
+//         super();
+//     }
+
+//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
+//         const {blockL1GasLimit} = machineState.executionEnvironment.globals;
+
+//         machineState.memory.set(this.destOffset, blockL1GasLimit);
+
+//         this.incrementPc(machineState);
+//     }
+// }
+
+// export class BlockL2GasLimit extends GetterInstruction {
+//     static type: string = 'BLOCKL2GASLIMIT';
+//     static numberOfOperands = 1;
+
+//     constructor(private destOffset: number) {
+//         super();
+//     }
+
+//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
+//         const {blockL2GasLimit} = machineState.executionEnvironment.globals;
+
+//         machineState.memory.set(this.destOffset, blockL2GasLimit);
+
+//         this.incrementPc(machineState);
+//     }
+// }
+
+// export class BlockDAGasLimit extends GetterInstruction {
+//     static type: string = 'BLOCKDAGASLIMIT';
+//     static numberOfOperands = 1;
+
+//     constructor(private destOffset: number) {
+//         super();
+//     }
+
+//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
+//         const {blockDAGasLimit} = machineState.executionEnvironment.globals;
+
+//         machineState.memory.set(this.destOffset, blockDAGasLimit);
+
+//         this.incrementPc(machineState);
+//     }
+// }

package/src/avm/opcodes/external_calls.ts

@@ -0,0 +1,122 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AvmContext } from '../avm_context.js';
+import { Field } from '../avm_memory_types.js';
+import { AvmSimulator } from '../avm_simulator.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+
+export class Call extends Instruction {
+  static type: string = 'CALL';
+  static readonly opcode: Opcode = Opcode.CALL;
+  // 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,
+  ];
+
+  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,
+  ) {
+    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 callAddress = context.machineState.memory.getAs<Field>(this.addrOffset);
+    const calldata = context.machineState.memory.getSlice(this.argsOffset, this.argsSize).map(f => f.toFr());
+
+    const nestedContext = context.createNestedContractCallContext(callAddress.toFr(), calldata);
+
+    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(this.successOffset, new Field(success ? 1 : 0));
+    context.machineState.memory.setSlice(this.retOffset, convertedReturnData);
+
+    if (success) {
+      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
+    } else {
+      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
+    }
+
+    context.machineState.incrementPc();
+  }
+}
+
+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,
+  ];
+
+  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,
+  ) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const callAddress = context.machineState.memory.get(this.addrOffset);
+    const calldata = context.machineState.memory
+      .getSlice(this.argsOffset, this.argsSize)
+      .map(f => new Fr(f.toBigInt()));
+
+    const nestedContext = context.createNestedContractStaticCallContext(callAddress.toFr(), calldata);
+
+    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(this.successOffset, new Field(success ? 1 : 0));
+    context.machineState.memory.setSlice(this.retOffset, convertedReturnData);
+
+    if (success) {
+      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
+    } else {
+      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
+    }
+
+    context.machineState.incrementPc();
+  }
+}