@aztec/simulator 0.0.1-commit.c80b6263 → 0.0.1-commit.cd76b27

package/src/public/avm/fixtures/account_proof_fetcher.ts

@@ -0,0 +1,166 @@
+/**
+ * Fetches an account proof from the Ethereum mainnet and saves it as account_proof.json.
+ * This script is not using any Aztec library code, so it's easily portable.
+ */
+import fs from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createPublicClient, fromRlp, hexToBytes, http } from 'viem';
+import { mainnet } from 'viem/chains';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const RPC_URL = process.env.RPC_URL;
+const ADDRESS = (process.env.ADDRESS || '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045') as `0x${string}`;
+const BLOCK_TAG = process.env.BLOCK_NUMBER ? BigInt(process.env.BLOCK_NUMBER) : 'latest';
+const MAX_ACCOUNT_PATH = 15;
+
+function padTo(arr: number[], len: number) {
+  return [...arr, ...Array(len - arr.length).fill(0)].slice(0, len);
+}
+
+function toBytes(hex: `0x${string}`) {
+  return Array.from(hexToBytes(hex));
+}
+
+function bytesToU64s(bytes: number[]) {
+  const paddedBytes = padTo(bytes, 32);
+  return Array.from({ length: 4 }, (_, i) => {
+    let val = 0n;
+    for (let j = 0; j < 8; j++) {
+      val += BigInt(paddedBytes[i * 8 + j]) << BigInt(j * 8);
+    }
+    return val.toString();
+  });
+}
+
+function toBytesAndLen(val: bigint | number) {
+  if (val === 0n || val === 0) {
+    return { bytes: [0], length: 0 };
+  }
+  let hex = val.toString(16);
+  if (hex.length % 2) {
+    hex = '0' + hex;
+  }
+  const bytes = toBytes(`0x${hex}`);
+  return { bytes, length: bytes.length };
+}
+
+function parseNode(rlp: `0x${string}`) {
+  // Should be safe when working with branches and extensions without embedded children.
+  const decoded = fromRlp(rlp) as `0x${string}`[];
+  const node = {
+    rows: Array(16)
+      .fill(0)
+      .map(() => Array(32).fill(0)),
+    row_exist: Array(16).fill(false),
+    node_type: 0,
+  };
+
+  if (decoded.length === 17) {
+    for (let i = 0; i < 16; i++) {
+      if (decoded[i] !== '0x') {
+        node.row_exist[i] = true;
+        node.rows[i] = padTo(toBytes(decoded[i]), 32);
+      }
+    }
+  } else if (decoded.length === 2) {
+    const keyBytes = toBytes(decoded[0]);
+    const prefix = keyBytes[0];
+    if (prefix >> 4 >= 2) {
+      throw new Error('Unsupported: leaf node in proof path');
+    }
+    node.node_type = 1;
+    // Extension header format expected by the noir code: check out storage_proof types.nr.
+    node.rows[0][0] = prefix >> 4;
+    node.rows[0][8] = prefix & 0x0f;
+    node.rows[0][16] = keyBytes.length - 1;
+
+    for (let i = 1; i < keyBytes.length && i < 32; i++) {
+      node.rows[1][i - 1] = keyBytes[i];
+    }
+    node.rows[2] = padTo(toBytes(decoded[1]), 32);
+    node.row_exist[0] = node.row_exist[1] = node.row_exist[2] = true;
+  }
+  return node;
+}
+
+function parseProof(proof: `0x${string}`[], maxLen: number) {
+  const nodes = proof.slice(0, -1).slice(0, maxLen).map(parseNode);
+  while (nodes.length < maxLen) {
+    nodes.push({
+      rows: Array(16)
+        .fill(0)
+        .map(() => Array(32).fill(0)),
+      row_exist: Array(16).fill(false),
+      node_type: 0,
+    });
+  }
+  return nodes;
+}
+
+function nodeToLibFormat(node: { rows: number[][]; row_exist: boolean[]; node_type: number }) {
+  return {
+    rows: node.rows.map(bytesToU64s),
+    row_exist: node.row_exist,
+    node_type: String(node.node_type),
+  };
+}
+
+async function main() {
+  if (!RPC_URL) {
+    throw new Error('RPC_URL is not set');
+  }
+  console.log(`Fetching account proof for ${ADDRESS}`);
+
+  const client = createPublicClient({
+    chain: mainnet,
+    transport: http(RPC_URL),
+  });
+
+  const [blockNumber, proof, block] = await Promise.all([
+    client.getBlockNumber(),
+    client.getProof({
+      address: ADDRESS,
+      storageKeys: [],
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+    client.getBlock({
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+  ]);
+
+  console.log(`Block: ${blockNumber}, Account nodes: ${proof.accountProof.length}`);
+
+  // The -1 is because the last node in the proof is the leaf, which is excluded from path verification.
+  const accountPathLen = proof.accountProof.length - 1;
+  if (accountPathLen > MAX_ACCOUNT_PATH) {
+    throw new Error(
+      `Account proof path length ${accountPathLen} exceeds MAX_ACCOUNT_PATH ${MAX_ACCOUNT_PATH}. Increase the limit.`,
+    );
+  }
+
+  const nonce = toBytesAndLen(proof.nonce);
+  const balance = toBytesAndLen(proof.balance);
+
+  const data = {
+    block_number: String(blockNumber),
+    node_length: String(accountPathLen),
+    root: bytesToU64s(toBytes(block.stateRoot)),
+    nodes: parseProof(proof.accountProof, MAX_ACCOUNT_PATH).map(nodeToLibFormat),
+    account: {
+      address: toBytes(ADDRESS).map(String),
+      balance: padTo(balance.bytes, 32).map(String),
+      balance_length: String(balance.length),
+      code_hash: bytesToU64s(toBytes(proof.codeHash)),
+      nonce: padTo(nonce.bytes, 8).map(String),
+      nonce_length: String(nonce.length),
+      storage_hash: bytesToU64s(toBytes(proof.storageHash)),
+    },
+  };
+
+  fs.writeFileSync(join(__dirname, 'account_proof.json'), JSON.stringify(data, null, 2));
+  console.log('account_proof.json generated');
+}
+
+main().catch(console.error);

package/src/public/avm/opcodes/accrued_substate.ts

@@ -204,10 +204,9 @@ export class L1ToL2MessageExists extends Instruction {
   }
 }
 
-export class EmitUnencryptedLog extends Instruction {
-  // TODO(#11124): rename unencrypted -> public
-  static type: string = 'EMITUNENCRYPTEDLOG';
-  static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
+export class EmitPublicLog extends Instruction {
+  static type: string = 'EMITPUBLICLOG';
+  static readonly opcode: Opcode = Opcode.EMITPUBLICLOG;
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 

package/src/public/avm/serialization/bytecode_serialization.ts

@@ -19,7 +19,7 @@ import {
   EcAdd,
   EmitNoteHash,
   EmitNullifier,
-  EmitUnencryptedLog,
+  EmitPublicLog,
   Eq,
   FieldDiv,
   GetContractInstance,
@@ -129,7 +129,7 @@ export const INSTRUCTION_SET = new Map<Opcode, InstructionDeserializer>([
   [L1ToL2MessageExists.opcode, Instruction.fromBuffer.bind(L1ToL2MessageExists)], // Messages
 
   // Accrued Substate
-  [EmitUnencryptedLog.opcode, Instruction.fromBuffer.bind(EmitUnencryptedLog)],
+  [EmitPublicLog.opcode, Instruction.fromBuffer.bind(EmitPublicLog)],
   [SendL2ToL1Message.opcode, Instruction.fromBuffer.bind(SendL2ToL1Message)],
   [GetContractInstance.opcode, Instruction.fromBuffer.bind(GetContractInstance)],
 

package/src/public/avm/serialization/instruction_serialization.ts

@@ -70,7 +70,7 @@ export enum Opcode {
   EMITNULLIFIER,
   L1TOL2MSGEXISTS,
   GETCONTRACTINSTANCE,
-  EMITUNENCRYPTEDLOG,
+  EMITPUBLICLOG,
   SENDL2TOL1MSG,
   // External calls
   CALL,

package/src/public/fixtures/amm_test.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
@@ -326,6 +326,6 @@ async function removeLiquidity(
 async function computePartialNoteValidityCommitment(partialNote: { commitment: Fr }, completer: AztecAddress) {
   return await poseidon2HashWithSeparator(
     [partialNote.commitment, completer],
-    GeneratorIndex.PARTIAL_NOTE_VALIDITY_COMMITMENT,
+    DomainSeparator.PARTIAL_NOTE_VALIDITY_COMMITMENT,
   );
 }

package/src/public/fixtures/opcode_spammer.ts

@@ -143,7 +143,7 @@
  * - `EMITNOTEHASH`: max 64 per TX
  * - `EMITNULLIFIER`: max 63 per TX (one reserved for TX nullifier)
  * - `SENDL2TOL1MSG`: max 8 per TX
- * - `EMITUNENCRYPTEDLOG`: limited by total log payload size
+ * - `EMITPUBLICLOG`: limited by total log payload size
  *
  * By having the inner contract REVERT after emitting side effects, those effects are discarded, allowing the outer contract to call it again. This enables thousands of opcode executions per TX instead of just the limit.
  *
@@ -182,7 +182,7 @@ import {
   EcAdd,
   EmitNoteHash,
   EmitNullifier,
-  EmitUnencryptedLog,
+  EmitPublicLog,
   Eq,
   FieldDiv,
   GetContractInstance,
@@ -1242,17 +1242,15 @@ export const SPAM_CONFIGS: Partial<Record<Opcode, SpamConfig[]>> = {
     },
   ],
 
-  // EMITUNENCRYPTEDLOG - two configs: minimal (many small logs) and max-size (one large log)
-  [Opcode.EMITUNENCRYPTEDLOG]: [
+  // EMITPUBLICLOG - two configs: minimal (many small logs) and max-size (one large log)
+  [Opcode.EMITPUBLICLOG]: [
     {
       label: 'Many empty logs, revert, repeat',
       setup: [
         { offset: 0, value: new Uint32(0n) }, // logSize = 0 fields (minimal)
         { offset: 1, value: new Uint32(0n) }, // revertSize
       ],
-      targetInstructions: () => [
-        new EmitUnencryptedLog(/*addressing_mode=*/ 0, /*logSizeOffset=*/ 0, /*logOffset=*/ 1),
-      ], // logOffset doesn't matter when size is 0
+      targetInstructions: () => [new EmitPublicLog(/*addressing_mode=*/ 0, /*logSizeOffset=*/ 0, /*logOffset=*/ 1)], // logOffset doesn't matter when size is 0
       cleanupInstructions: () => [
         new Revert(/*addressing_mode=*/ 0, /*retSizeOffset=*/ 1, /*returnOffset=*/ 0).as(
           Opcode.REVERT_8,
@@ -1276,9 +1274,7 @@ export const SPAM_CONFIGS: Partial<Record<Opcode, SpamConfig[]>> = {
         //  value: new Field(0n),
         //})),
       ],
-      targetInstructions: () => [
-        new EmitUnencryptedLog(/*addressing_mode=*/ 0, /*logSizeOffset=*/ 0, /*logOffset=*/ 2),
-      ], // uses logOffset 2 (uninitialized Field(0))
+      targetInstructions: () => [new EmitPublicLog(/*addressing_mode=*/ 0, /*logSizeOffset=*/ 0, /*logOffset=*/ 2)], // uses logOffset 2 (uninitialized Field(0))
       cleanupInstructions: () => [
         new Revert(/*addressing_mode=*/ 0, /*retSizeOffset=*/ 1, /*returnOffset=*/ 0).as(
           Opcode.REVERT_8,

package/src/public/fixtures/utils.ts

@@ -134,13 +134,13 @@ export async function createTxForPublicCalls(
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const header = BlockHeader.empty({ globalVariables: globals });
   const constantData = new TxConstantData(header, txContext, Fr.zero(), Fr.zero());
-  const includeByTimestamp = 0n; // Not used in the simulator.
+  const expirationTimestamp = 0n; // Not used in the simulator.
 
   const txData = new PrivateKernelTailCircuitPublicInputs(
     constantData,
     /*gasUsed=*/ gasUsedByPrivate,
     feePayer,
-    includeByTimestamp,
+    expirationTimestamp,
     forPublic,
   );
 
@@ -171,13 +171,13 @@ export async function createTxForPrivateOnly(
   const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
-  const includeByTimestamp = 0n; // Not used in the simulator.
+  const expirationTimestamp = 0n; // Not used in the simulator.
 
   const txData = new PrivateKernelTailCircuitPublicInputs(
     constantData,
     /*gasUsed=*/ gasUsedByPrivate,
     feePayer,
-    includeByTimestamp,
+    expirationTimestamp,
     /*forPublic=*/ undefined,
     forRollup,
   );

package/src/public/fuzzing/avm_fuzzer_simulator.ts

@@ -146,7 +146,7 @@ async function createTxFromHint(cppTx: AvmTxHint): Promise<Tx> {
     constants,
     cppTx.gasUsedByPrivate,
     cppTx.feePayer,
-    0n, // includeByTimestamp
+    0n, // expirationTimestamp
     forPublic,
     undefined, // forRollup - not needed for public simulation
   );

package/src/public/hinting_db_sources.ts

@@ -572,7 +572,7 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
     return await this.db.close();
   }
 
-  async [Symbol.dispose](): Promise<void> {
+  async [Symbol.asyncDispose](): Promise<void> {
     await this.close();
   }
 

package/src/public/public_processor/guarded_merkle_tree.ts

@@ -82,7 +82,7 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
     return this.guardAndPush(() => this.target.close());
   }
 
-  async [Symbol.dispose](): Promise<void> {
+  async [Symbol.asyncDispose](): Promise<void> {
     await this.close();
   }
   getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {