@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -1,121 +0,0 @@
-import { Fq, Point } from '@aztec/circuits.js';
-import { Grumpkin } from '@aztec/circuits.js/barretenberg';
-
-import { type AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
-import { MSMPointNotOnCurveError, MSMPointsLengthError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class MultiScalarMul extends Instruction {
-  static type: string = 'MultiScalarMul';
-  static readonly opcode: Opcode = Opcode.MSM;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8 /* opcode */,
-    OperandType.UINT8 /* indirect */,
-    OperandType.UINT16 /* points vector offset */,
-    OperandType.UINT16 /* scalars vector offset */,
-    OperandType.UINT16 /* output offset (fixed triplet) */,
-    OperandType.UINT16 /* points length offset */,
-  ];
-
-  constructor(
-    private indirect: number,
-    private pointsOffset: number,
-    private scalarsOffset: number,
-    private outputOffset: number,
-    private pointsLengthOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    // Resolve indirects
-    const operands = [this.pointsOffset, this.scalarsOffset, this.outputOffset, this.pointsLengthOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [pointsOffset, scalarsOffset, outputOffset, pointsLengthOffset] = addressing.resolve(operands, memory);
-
-    // Length of the points vector should be U32
-    memory.checkTag(TypeTag.UINT32, pointsLengthOffset);
-    // Get the size of the unrolled (x, y , inf) points vector
-    const pointsReadLength = memory.get(pointsLengthOffset).toNumber();
-    if (pointsReadLength % 3 !== 0) {
-      throw new MSMPointsLengthError(pointsReadLength);
-    }
-
-    // Get the unrolled (x, y, inf) representing the points
-    // Important to perform this before tag validation, as getSlice() first checks
-    // that the slice is not out of memory range. This needs to be aligned with circuit.
-    const pointsVector = memory.getSlice(pointsOffset, pointsReadLength);
-
-    // Divide by 3 since each point is represented as a triplet to get the number of points
-    const numPoints = pointsReadLength / 3;
-    // The tag for each triplet will be (Field, Field, Uint8)
-    for (let i = 0; i < numPoints; i++) {
-      const offset = pointsOffset + i * 3;
-      // Check (Field, Field)
-      memory.checkTagsRange(TypeTag.FIELD, offset, 2);
-      // Check Uint1 (inf flag)
-      memory.checkTag(TypeTag.UINT1, offset + 2);
-    }
-
-    // The size of the scalars vector is twice the NUMBER of points because of the scalar limb decomposition
-    const scalarReadLength = numPoints * 2;
-    context.machineState.consumeGas(this.gasCost(pointsReadLength));
-    // Get the unrolled scalar (lo & hi) representing the scalars
-    const scalarsVector = memory.getSlice(scalarsOffset, scalarReadLength);
-    memory.checkTagsRange(TypeTag.FIELD, scalarsOffset, scalarReadLength);
-
-    // Now we need to reconstruct the points and scalars into something we can operate on.
-    const grumpkinPoints: Point[] = [];
-    for (let i = 0; i < numPoints; i++) {
-      const isInf = pointsVector[3 * i + 2].toNumber() === 1;
-      const p: Point = new Point(pointsVector[3 * i].toFr(), pointsVector[3 * i + 1].toFr(), isInf);
-      if (!p.isOnGrumpkin()) {
-        throw new MSMPointNotOnCurveError(p);
-      }
-      grumpkinPoints.push(p);
-    }
-    // The scalars are read from memory as Fr elements, which are limbs of Fq elements
-    // So we need to reconstruct them before performing the scalar multiplications
-    const scalarFqVector: Fq[] = [];
-    for (let i = 0; i < numPoints; i++) {
-      const scalarLo = scalarsVector[2 * i].toFr();
-      const scalarHi = scalarsVector[2 * i + 1].toFr();
-      const fqScalar = Fq.fromHighLow(scalarHi, scalarLo);
-      scalarFqVector.push(fqScalar);
-    }
-    // TODO: Is there an efficient MSM implementation in ts that we can replace this by?
-    const grumpkin = new Grumpkin();
-    // Zip the points and scalars into pairs
-    const [firstBaseScalarPair, ...rest]: Array<[Point, Fq]> = grumpkinPoints.map((p, idx) => [p, scalarFqVector[idx]]);
-    // Fold the points and scalars into a single point
-    // We have to ensure get the first point, since the identity element (point at infinity) isn't quite working in ts
-    let acc = await grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]);
-    for (const curr of rest) {
-      if (curr[1] === Fq.ZERO) {
-        // If we multiply by 0, the result will the point at infinity - so we ignore it
-        continue;
-      } else if (curr[0].inf) {
-        // If we multiply the point at infinity by a scalar, it's still the point at infinity
-        continue;
-      } else if (acc.inf) {
-        // If we accumulator is the point at infinity, we can just return the current point
-        acc = curr[0];
-      } else {
-        acc = await grumpkin.add(acc, await grumpkin.mul(curr[0], curr[1]));
-      }
-    }
-    const outputPoint = acc;
-
-    // Important to use setSlice() and not set() in the two following statements as
-    // this checks that the offsets lie within memory range.
-    memory.setSlice(outputOffset, [new Field(outputPoint.x), new Field(outputPoint.y)]);
-    // Check representation of infinity for grumpkin
-    memory.setSlice(outputOffset + 2, [new Uint1(outputPoint.equals(Point.ZERO) ? 1 : 0)]);
-  }
-}

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,212 +0,0 @@
-import { AvmExecutionError, AvmParsingError, InvalidOpcodeError, InvalidProgramCounterError } from '../errors.js';
-import {
-  Add,
-  And,
-  Call,
-  CalldataCopy,
-  Cast,
-  DebugLog,
-  Div,
-  EcAdd,
-  EmitNoteHash,
-  EmitNullifier,
-  EmitUnencryptedLog,
-  Eq,
-  FieldDiv,
-  GetContractInstance,
-  GetEnvVar,
-  Instruction,
-  InternalCall,
-  InternalReturn,
-  Jump,
-  JumpI,
-  KeccakF1600,
-  L1ToL2MessageExists,
-  Lt,
-  Lte,
-  Mov,
-  Mul,
-  Not,
-  NoteHashExists,
-  NullifierExists,
-  Or,
-  Poseidon2,
-  Return,
-  ReturndataCopy,
-  ReturndataSize,
-  Revert,
-  SLoad,
-  SStore,
-  SendL2ToL1Message,
-  Set,
-  Sha256Compression,
-  Shl,
-  Shr,
-  StaticCall,
-  Sub,
-  ToRadixBE,
-  Xor,
-} from '../opcodes/index.js';
-import { MultiScalarMul } from '../opcodes/multi_scalar_mul.js';
-import { BufferCursor } from './buffer_cursor.js';
-import { MAX_OPCODE_VALUE, Opcode } from './instruction_serialization.js';
-
-export type InstructionDeserializer = (buf: BufferCursor | Buffer) => Instruction;
-
-export interface Serializable {
-  serialize(): Buffer;
-}
-
-export interface Deserializable {
-  deserialize: InstructionDeserializer;
-}
-
-export type InstructionSet = Map<Opcode, InstructionDeserializer>;
-// TODO(4359): This is a function so that Call and StaticCall can be lazily resolved.
-// This is a temporary solution until we solve the dependency cycle.
-export const INSTRUCTION_SET = () =>
-  new Map<Opcode, InstructionDeserializer>([
-    [Opcode.ADD_8, Add.as(Add.wireFormat8).deserialize],
-    [Opcode.ADD_16, Add.as(Add.wireFormat16).deserialize],
-    [Opcode.SUB_8, Sub.as(Sub.wireFormat8).deserialize],
-    [Opcode.SUB_16, Sub.as(Sub.wireFormat16).deserialize],
-    [Opcode.MUL_8, Mul.as(Mul.wireFormat8).deserialize],
-    [Opcode.MUL_16, Mul.as(Mul.wireFormat16).deserialize],
-    [Opcode.DIV_8, Div.as(Div.wireFormat8).deserialize],
-    [Opcode.DIV_16, Div.as(Div.wireFormat16).deserialize],
-    [Opcode.FDIV_8, FieldDiv.as(FieldDiv.wireFormat8).deserialize],
-    [Opcode.FDIV_16, FieldDiv.as(FieldDiv.wireFormat16).deserialize],
-    [Opcode.EQ_8, Eq.as(Eq.wireFormat8).deserialize],
-    [Opcode.EQ_16, Eq.as(Eq.wireFormat16).deserialize],
-    [Opcode.LT_8, Lt.as(Lt.wireFormat8).deserialize],
-    [Opcode.LT_16, Lt.as(Lt.wireFormat16).deserialize],
-    [Opcode.LTE_8, Lte.as(Lte.wireFormat8).deserialize],
-    [Opcode.LTE_16, Lte.as(Lte.wireFormat16).deserialize],
-    [Opcode.AND_8, And.as(And.wireFormat8).deserialize],
-    [Opcode.AND_16, And.as(And.wireFormat16).deserialize],
-    [Opcode.OR_8, Or.as(Or.wireFormat8).deserialize],
-    [Opcode.OR_16, Or.as(Or.wireFormat16).deserialize],
-    [Opcode.XOR_8, Xor.as(Xor.wireFormat8).deserialize],
-    [Opcode.XOR_16, Xor.as(Xor.wireFormat16).deserialize],
-    [Opcode.NOT_8, Not.as(Not.wireFormat8).deserialize],
-    [Opcode.NOT_16, Not.as(Not.wireFormat16).deserialize],
-    [Opcode.SHL_8, Shl.as(Shl.wireFormat8).deserialize],
-    [Opcode.SHL_16, Shl.as(Shl.wireFormat16).deserialize],
-    [Opcode.SHR_8, Shr.as(Shr.wireFormat8).deserialize],
-    [Opcode.SHR_16, Shr.as(Shr.wireFormat16).deserialize],
-    [Opcode.CAST_8, Cast.as(Cast.wireFormat8).deserialize],
-    [Opcode.CAST_16, Cast.as(Cast.wireFormat16).deserialize],
-    // Execution Environment
-    [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).deserialize],
-    [CalldataCopy.opcode, Instruction.deserialize.bind(CalldataCopy)],
-    [Opcode.RETURNDATASIZE, Instruction.deserialize.bind(ReturndataSize)],
-    [Opcode.RETURNDATACOPY, Instruction.deserialize.bind(ReturndataCopy)],
-
-    // Machine State - Internal Control Flow
-    [Jump.opcode, Instruction.deserialize.bind(Jump)],
-    [JumpI.opcode, Instruction.deserialize.bind(JumpI)],
-    [InternalCall.opcode, Instruction.deserialize.bind(InternalCall)],
-    [InternalReturn.opcode, Instruction.deserialize.bind(InternalReturn)],
-    [Opcode.SET_8, Set.as(Set.wireFormat8).deserialize],
-    [Opcode.SET_16, Set.as(Set.wireFormat16).deserialize],
-    [Opcode.SET_32, Set.as(Set.wireFormat32).deserialize],
-    [Opcode.SET_64, Set.as(Set.wireFormat64).deserialize],
-    [Opcode.SET_128, Set.as(Set.wireFormat128).deserialize],
-    [Opcode.SET_FF, Set.as(Set.wireFormatFF).deserialize],
-    [Opcode.MOV_8, Mov.as(Mov.wireFormat8).deserialize],
-    [Opcode.MOV_16, Mov.as(Mov.wireFormat16).deserialize],
-
-    // World State
-    [SLoad.opcode, Instruction.deserialize.bind(SLoad)], // Public Storage
-    [SStore.opcode, Instruction.deserialize.bind(SStore)], // Public Storage
-    [NoteHashExists.opcode, Instruction.deserialize.bind(NoteHashExists)], // Notes & Nullifiers
-    [EmitNoteHash.opcode, Instruction.deserialize.bind(EmitNoteHash)], // Notes & Nullifiers
-    [NullifierExists.opcode, Instruction.deserialize.bind(NullifierExists)], // Notes & Nullifiers
-    [EmitNullifier.opcode, Instruction.deserialize.bind(EmitNullifier)], // Notes & Nullifiers
-    [L1ToL2MessageExists.opcode, Instruction.deserialize.bind(L1ToL2MessageExists)], // Messages
-
-    // Accrued Substate
-    [EmitUnencryptedLog.opcode, Instruction.deserialize.bind(EmitUnencryptedLog)],
-    [SendL2ToL1Message.opcode, Instruction.deserialize.bind(SendL2ToL1Message)],
-    [GetContractInstance.opcode, Instruction.deserialize.bind(GetContractInstance)],
-
-    // Control Flow - Contract Calls
-    [Call.opcode, Instruction.deserialize.bind(Call)],
-    [StaticCall.opcode, Instruction.deserialize.bind(StaticCall)],
-    [Return.opcode, Instruction.deserialize.bind(Return)],
-    [Opcode.REVERT_8, Revert.as(Revert.wireFormat8).deserialize],
-    [Opcode.REVERT_16, Revert.as(Revert.wireFormat16).deserialize],
-
-    // Misc
-    [DebugLog.opcode, Instruction.deserialize.bind(DebugLog)],
-
-    // Gadgets
-    [EcAdd.opcode, Instruction.deserialize.bind(EcAdd)],
-    [Poseidon2.opcode, Instruction.deserialize.bind(Poseidon2)],
-    [Sha256Compression.opcode, Instruction.deserialize.bind(Sha256Compression)],
-    [KeccakF1600.opcode, Instruction.deserialize.bind(KeccakF1600)],
-    [MultiScalarMul.opcode, Instruction.deserialize.bind(MultiScalarMul)],
-
-    // Conversions
-    [ToRadixBE.opcode, Instruction.deserialize.bind(ToRadixBE)],
-  ]);
-
-/**
- * Serializes an array of instructions to bytecode.
- */
-export function encodeToBytecode(instructions: Serializable[]): Buffer {
-  return Buffer.concat(instructions.map(i => i.serialize()));
-}
-
-// For testing only
-export function decodeFromBytecode(
-  bytecode: Buffer,
-  instructionSet: InstructionSet = INSTRUCTION_SET(),
-): Instruction[] {
-  const instructions: Instruction[] = [];
-  let pc = 0;
-  while (pc < bytecode.length) {
-    const [instruction, bytesConsumed] = decodeInstructionFromBytecode(bytecode, pc, instructionSet);
-    instructions.push(instruction);
-    pc += bytesConsumed;
-  }
-  return instructions;
-}
-
-// Returns the instruction and the number of bytes consumed.
-export function decodeInstructionFromBytecode(
-  bytecode: Buffer,
-  pc: number,
-  instructionSet: InstructionSet = INSTRUCTION_SET(),
-): [Instruction, number] {
-  if (pc >= bytecode.length) {
-    throw new InvalidProgramCounterError(pc, bytecode.length);
-  }
-
-  try {
-    const cursor = new BufferCursor(bytecode, pc);
-    const startingPosition = cursor.position();
-    const opcode: number = cursor.bufferAtPosition().readUint8(); // peek.
-
-    if (opcode > MAX_OPCODE_VALUE) {
-      throw new InvalidOpcodeError(
-        `Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes.`,
-      );
-    }
-
-    const instructionDeserializerOrUndef = instructionSet.get(opcode);
-    if (instructionDeserializerOrUndef === undefined) {
-      throw new InvalidOpcodeError(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) is not implemented`);
-    }
-
-    const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
-    const instruction = instructionDeserializer(cursor);
-    return [instruction, cursor.position() - startingPosition];
-  } catch (error) {
-    if (error instanceof InvalidOpcodeError || error instanceof AvmExecutionError) {
-      throw error;
-    } else {
-      throw new AvmParsingError(`${error}`);
-    }
-  }
-}

package/src/client/index.ts

@@ -1,15 +0,0 @@
-export { AcirSimulator } from './simulator.js';
-export { ViewDataOracle } from './view_data_oracle.js';
-export { DBOracle, ContractClassNotFoundError, ContractNotFoundError } from './db_oracle.js';
-export * from './pick_notes.js';
-export { ExecutionNoteCache } from './execution_note_cache.js';
-export { extractPrivateCircuitPublicInputs } from './private_execution.js';
-export { witnessMapToFields } from '../acvm/deserialize.js';
-export { toACVMWitness } from '../acvm/serialize.js';
-export { extractCallStack } from '../acvm/acvm.js';
-export { WASMSimulator } from '../providers/acvm_wasm.js';
-export { NoteData, TypedOracle } from '../acvm/oracle/typed_oracle.js';
-export { Oracle } from '../acvm/oracle/oracle.js';
-export { type SimulationProvider } from '../common/simulation_provider.js';
-export { MessageLoadOracleInputs } from '../common/message_load_oracle_inputs.js';
-export { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '../common/errors.js';

package/src/common.ts

@@ -1 +0,0 @@
-export * from './common/index.js';

package/src/providers/index.ts

@@ -1,4 +0,0 @@
-export * from './acvm_native.js';
-export * from './acvm_wasm_with_blobs.js';
-export * from '../common/simulation_provider.js';
-export * from './factory.js';

package/src/public/fee_payment.ts

@@ -1,23 +0,0 @@
-import { computePublicDataTreeLeafSlot, deriveStorageSlotInMap } from '@aztec/circuits.js/hash';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr } from '@aztec/foundation/fields';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { FeeJuiceArtifact } from '@aztec/protocol-contracts/fee-juice';
-
-/**
- * Computes the storage slot within the Fee Juice contract for the balance of the fee payer.
- */
-export function computeFeePayerBalanceStorageSlot(feePayer: AztecAddress) {
-  return deriveStorageSlotInMap(FeeJuiceArtifact.storageLayout.balances.slot, feePayer);
-}
-
-/**
- * Computes the leaf slot in the public data tree for the balance of the fee payer in the Fee Juice.
- */
-export async function computeFeePayerBalanceLeafSlot(feePayer: AztecAddress): Promise<Fr> {
-  if (feePayer.isZero()) {
-    return Fr.ZERO;
-  }
-  const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
-  return computePublicDataTreeLeafSlot(ProtocolContractAddress.FeeJuice, balanceSlot);
-}