@aztec/simulator 0.0.0-test.0

package/src/public/unique_class_ids.ts

@@ -0,0 +1,80 @@
+import { MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS } from '@aztec/constants';
+
+import { strict as assert } from 'assert';
+
+/**
+ * A class manage a de-duplicated set of class IDs that errors if you try to add a duplicate.
+ * Useful for bytecode retrieval hints to avoid duplicates in parent trace & grandparent trace....
+ */
+export class UniqueClassIds {
+  private readonly classIds: Set<string> = new Set();
+
+  constructor(private readonly parent?: UniqueClassIds) {}
+
+  /**
+   * Create a fork that references this one as its parent
+   */
+  public fork() {
+    return new UniqueClassIds(/*parent=*/ this);
+  }
+
+  /**
+   * Check for a class ID here or in parent's (recursively).
+   *
+   * @param classId - the contract class ID (as a string) to check
+   * @returns boolean: whether the class ID is here
+   */
+  public has(classId: string): boolean {
+    // First try check this' classIds
+    let here = this.classIds.has(classId);
+    // Then try parent's
+    if (!here && this.parent) {
+      // Note: this will recurse to grandparent/etc until we reach top or find it
+      here = this.parent.has(classId);
+    }
+    return here;
+  }
+
+  /**
+   * Get the total number of classIds
+   */
+  public size(): number {
+    return this.classIds.size + (this.parent ? this.parent.size() : 0);
+  }
+
+  /**
+   * Add a class ID (if not already present) to the set.
+   *
+   * @param classId - the contract class ID (as a string)
+   */
+  public add(classId: string) {
+    assert(!this.has(classId), `Bug! Tried to add duplicate classId ${classId} to set of unique classIds.`);
+    if (!this.has(classId)) {
+      this.classIds.add(classId);
+      assert(
+        this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+        `Bug! Surpassed limit (${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}) of unique contract class IDs used for bytecode retrievals.`,
+      );
+    }
+  }
+
+  /**
+   * Merge in another set of unique class IDs into this one, but fail on duplicates.
+   *
+   * @param incoming: other unique class IDs
+   */
+  public acceptAndMerge(incoming: UniqueClassIds) {
+    for (const classId of incoming.classIds.keys()) {
+      assert(
+        !this.has(classId),
+        `Bug! Cannot merge classId ${classId} into set of unique classIds as it already exists.`,
+      );
+      this.classIds.add(classId);
+    }
+    // since set() has an assertion, and size() always checks parent, this should be impossible
+    assert(
+      this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+      `Bug! Merging unique class Ids should never exceed the limit of ${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}.`,
+    );
+  }
+}

package/src/public/utils.ts

@@ -0,0 +1,32 @@
+import type { PublicCallRequest } from '@aztec/stdlib/kernel';
+import { type PublicExecutionRequest, type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+
+export function getExecutionRequestsByPhase(tx: Tx, phase: TxExecutionPhase): PublicExecutionRequest[] {
+  switch (phase) {
+    case TxExecutionPhase.SETUP:
+      return tx.getNonRevertiblePublicExecutionRequests();
+    case TxExecutionPhase.APP_LOGIC:
+      return tx.getRevertiblePublicExecutionRequests();
+    case TxExecutionPhase.TEARDOWN: {
+      const request = tx.getPublicTeardownExecutionRequest();
+      return request ? [request] : [];
+    }
+    default:
+      throw new Error(`Unknown phase: ${phase}`);
+  }
+}
+
+export function getCallRequestsByPhase(tx: Tx, phase: TxExecutionPhase): PublicCallRequest[] {
+  switch (phase) {
+    case TxExecutionPhase.SETUP:
+      return tx.data.getNonRevertiblePublicCallRequests();
+    case TxExecutionPhase.APP_LOGIC:
+      return tx.data.getRevertiblePublicCallRequests();
+    case TxExecutionPhase.TEARDOWN: {
+      const request = tx.data.getTeardownPublicCallRequest();
+      return request ? [request] : [];
+    }
+    default:
+      throw new Error(`Unknown phase: ${phase}`);
+  }
+}

package/src/server.ts

@@ -0,0 +1,5 @@
+export * from './public/index.js';
+export { WASMSimulatorWithBlobs } from './private/providers/acvm_wasm_with_blobs.js';
+export { NativeACVMSimulator } from './private/providers/acvm_native.js';
+export { type SimulationProvider } from './private/providers/simulation_provider.js';
+export * from './common/index.js';

package/src/test/utils.ts

@@ -0,0 +1,36 @@
+import { sha256ToField } from '@aztec/foundation/crypto';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computeSecretHash } from '@aztec/stdlib/hash';
+import { L1Actor, L1ToL2Message, L2Actor } from '@aztec/stdlib/messaging';
+
+/**
+ * Test utility function to craft an L1 to L2 message.
+ * @param selector - The cross chain message selector.
+ * @param contentPreimage - The args after the selector.
+ * @param targetContract - The contract to consume the message.
+ * @param secret - The secret to unlock the message.
+ * @returns The L1 to L2 message.
+ */
+export const buildL1ToL2Message = async (
+  selector: string,
+  contentPreimage: Fr[],
+  targetContract: AztecAddress,
+  secret: Fr,
+  msgIndex: Fr | number,
+) => {
+  // Write the selector into a buffer.
+  const selectorBuf = Buffer.from(selector, 'hex');
+
+  const content = sha256ToField([selectorBuf, ...contentPreimage]);
+  const secretHash = await computeSecretHash(secret);
+
+  return new L1ToL2Message(
+    new L1Actor(EthAddress.random(), 1),
+    new L2Actor(targetContract, 1),
+    content,
+    secretHash,
+    new Fr(msgIndex),
+  );
+};