@aztec/simulator 0.0.1-commit.24de95ac → 0.0.1-commit.2606882

package/src/public/avm/calldata.ts

@@ -0,0 +1,101 @@
+import type { Fr } from '@aztec/foundation/schemas';
+
+import { TaggedMemory } from './avm_memory_types.js';
+
+// Allow reading up to 300 kB of return data when unspecified.
+const DEFAULT_BEST_EFFORT_READ_CAP = 10000;
+
+export interface LazyReader {
+  bestEffortReadAll(readCap?: number): Fr[];
+  readAll(): Fr[];
+  read(idx: number): Fr | undefined;
+  slice(start: number, end: number): Fr[];
+  length(): number;
+}
+
+export class LazyReaderMemory implements LazyReader {
+  constructor(
+    private memory: TaggedMemory,
+    private offset: number,
+    private size: number,
+  ) {}
+
+  public bestEffortReadAll(readCap = DEFAULT_BEST_EFFORT_READ_CAP): Fr[] {
+    const size = Math.min(this.size, readCap, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
+    return this.memory.getSlice(this.offset, size).map(word => word.toFr());
+  }
+
+  public read(idx: number): Fr | undefined {
+    if (idx >= this.size) {
+      return undefined;
+    }
+    return this.memory.get(this.offset + idx).toFr();
+  }
+
+  public slice(start: number, end: number): Fr[] {
+    const clampedEnd = Math.min(end, this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
+    const length = Math.max(0, clampedEnd - start);
+    return this.memory.getSlice(this.offset + start, length).map(word => word.toFr());
+  }
+
+  public readAll(): Fr[] {
+    const size = Math.min(this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
+    return this.memory.getSlice(this.offset, size).map(word => word.toFr());
+  }
+
+  public length(): number {
+    return this.size;
+  }
+}
+
+export class LazyReaderArray implements LazyReader {
+  constructor(private array: Fr[]) {}
+
+  public bestEffortReadAll(readCap = DEFAULT_BEST_EFFORT_READ_CAP): Fr[] {
+    return this.array.slice(0, readCap);
+  }
+
+  public read(idx: number): Fr | undefined {
+    return this.array[idx];
+  }
+
+  public slice(start: number, end: number): Fr[] {
+    return this.array.slice(start, end);
+  }
+
+  public readAll(): Fr[] {
+    return this.array;
+  }
+
+  public length(): number {
+    return this.array.length;
+  }
+}
+
+// Compile time branding to avoid swapping CallData and ReturnData by accident.
+declare const CallDataBrand: unique symbol;
+declare const ReturnDataBrand: unique symbol;
+
+export type CallData = LazyReader & {
+  readonly [CallDataBrand]: true;
+};
+
+export type ReturnData = LazyReader & {
+  readonly [ReturnDataBrand]: true;
+};
+
+export class CallDataArray extends LazyReaderArray implements CallData {
+  declare readonly [CallDataBrand]: true;
+}
+
+export class CallDataMemory extends LazyReaderMemory implements CallData {
+  declare readonly [CallDataBrand]: true;
+}
+
+export class ReturnDataArray extends LazyReaderArray implements ReturnData {
+  declare readonly [ReturnDataBrand]: true;
+}
+
+export class ReturnDataMemory extends LazyReaderMemory implements ReturnData {
+  declare readonly [ReturnDataBrand]: true;
+}

package/src/public/avm/errors.ts

@@ -1,4 +1,4 @@
-import type { Point } from '@aztec/foundation/fields';
+import type { Point } from '@aztec/foundation/curves/grumpkin';
 import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
 
 import { ExecutionError } from '../../common/errors.js';
@@ -58,7 +58,7 @@ export class AvmParsingError extends AvmExecutionError {
  */
 export class InvalidTagValueError extends AvmExecutionError {
   constructor(tagValue: number) {
-    super(`Tag value ${tagValue} is invalid.`);
+    super(`Tag check failed: Tag value ${tagValue} is invalid.`);
     this.name = 'InvalidTagValueError';
   }
 }
@@ -77,6 +77,12 @@ export class InstructionExecutionError extends AvmExecutionError {
  * Error thrown on failed AVM memory tag check.
  */
 export class TagCheckError extends AvmExecutionError {
+  public static forBaseAddress(gotTag: string): TagCheckError {
+    return new TagCheckError(`Base address (mem[0]) is not a valid address (has tag ${gotTag})`);
+  }
+  public static forIndirectAddress(address: number, gotTag: string): TagCheckError {
+    return new TagCheckError(`Address after indirection is not a valid address (address ${address} has tag ${gotTag})`);
+  }
   public static forOffset(offset: number, gotTag: string, expectedTag: string): TagCheckError {
     return new TagCheckError(`Tag mismatch at offset ${offset}, got ${gotTag}, expected ${expectedTag}`);
   }
@@ -97,7 +103,7 @@ export class TagCheckError extends AvmExecutionError {
  */
 export class RelativeAddressOutOfRangeError extends AvmExecutionError {
   constructor(baseAddr: number, relOffset: number) {
-    super(`Address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
+    super(`Relative address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
     this.name = 'RelativeAddressOutOfRangeError';
   }
 }
@@ -161,3 +167,11 @@ export class AvmRevertReason extends ExecutionError {
     super(message, failingFunction, noirCallStack, options);
   }
 }
+
+/**
+ * Helper to annotate errors occurring during instruction fetching.
+ */
+export function duringInstrFetch(error: Error, pc: number) {
+  error.message = `Instruction fetching error at pc ${pc}: ${error.message}`;
+  return error;
+}