@aztec/simulator 0.85.0 → 0.86.0-nightly.20250425

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

@@ -1,3 +1,5 @@
+import { type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
+
 import { AvmExecutionError, AvmParsingError, InvalidOpcodeError, InvalidProgramCounterError } from '../errors.js';
 import {
   Add,
@@ -53,106 +55,102 @@ 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>;
 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],
+  [Opcode.ADD_8, Add.as(Add.wireFormat8).fromBuffer],
+  [Opcode.ADD_16, Add.as(Add.wireFormat16).fromBuffer],
+  [Opcode.SUB_8, Sub.as(Sub.wireFormat8).fromBuffer],
+  [Opcode.SUB_16, Sub.as(Sub.wireFormat16).fromBuffer],
+  [Opcode.MUL_8, Mul.as(Mul.wireFormat8).fromBuffer],
+  [Opcode.MUL_16, Mul.as(Mul.wireFormat16).fromBuffer],
+  [Opcode.DIV_8, Div.as(Div.wireFormat8).fromBuffer],
+  [Opcode.DIV_16, Div.as(Div.wireFormat16).fromBuffer],
+  [Opcode.FDIV_8, FieldDiv.as(FieldDiv.wireFormat8).fromBuffer],
+  [Opcode.FDIV_16, FieldDiv.as(FieldDiv.wireFormat16).fromBuffer],
+  [Opcode.EQ_8, Eq.as(Eq.wireFormat8).fromBuffer],
+  [Opcode.EQ_16, Eq.as(Eq.wireFormat16).fromBuffer],
+  [Opcode.LT_8, Lt.as(Lt.wireFormat8).fromBuffer],
+  [Opcode.LT_16, Lt.as(Lt.wireFormat16).fromBuffer],
+  [Opcode.LTE_8, Lte.as(Lte.wireFormat8).fromBuffer],
+  [Opcode.LTE_16, Lte.as(Lte.wireFormat16).fromBuffer],
+  [Opcode.AND_8, And.as(And.wireFormat8).fromBuffer],
+  [Opcode.AND_16, And.as(And.wireFormat16).fromBuffer],
+  [Opcode.OR_8, Or.as(Or.wireFormat8).fromBuffer],
+  [Opcode.OR_16, Or.as(Or.wireFormat16).fromBuffer],
+  [Opcode.XOR_8, Xor.as(Xor.wireFormat8).fromBuffer],
+  [Opcode.XOR_16, Xor.as(Xor.wireFormat16).fromBuffer],
+  [Opcode.NOT_8, Not.as(Not.wireFormat8).fromBuffer],
+  [Opcode.NOT_16, Not.as(Not.wireFormat16).fromBuffer],
+  [Opcode.SHL_8, Shl.as(Shl.wireFormat8).fromBuffer],
+  [Opcode.SHL_16, Shl.as(Shl.wireFormat16).fromBuffer],
+  [Opcode.SHR_8, Shr.as(Shr.wireFormat8).fromBuffer],
+  [Opcode.SHR_16, Shr.as(Shr.wireFormat16).fromBuffer],
+  [Opcode.CAST_8, Cast.as(Cast.wireFormat8).fromBuffer],
+  [Opcode.CAST_16, Cast.as(Cast.wireFormat16).fromBuffer],
   // Execution Environment
-  [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).deserialize],
-  [CalldataCopy.opcode, Instruction.deserialize.bind(CalldataCopy)],
-  [SuccessCopy.opcode, Instruction.deserialize.bind(SuccessCopy)],
-  [Opcode.RETURNDATASIZE, Instruction.deserialize.bind(ReturndataSize)],
-  [Opcode.RETURNDATACOPY, Instruction.deserialize.bind(ReturndataCopy)],
+  [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).fromBuffer],
+  [CalldataCopy.opcode, Instruction.fromBuffer.bind(CalldataCopy)],
+  [SuccessCopy.opcode, Instruction.fromBuffer.bind(SuccessCopy)],
+  [Opcode.RETURNDATASIZE, Instruction.fromBuffer.bind(ReturndataSize)],
+  [Opcode.RETURNDATACOPY, Instruction.fromBuffer.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],
+  [Jump.opcode, Instruction.fromBuffer.bind(Jump)],
+  [JumpI.opcode, Instruction.fromBuffer.bind(JumpI)],
+  [InternalCall.opcode, Instruction.fromBuffer.bind(InternalCall)],
+  [InternalReturn.opcode, Instruction.fromBuffer.bind(InternalReturn)],
+  [Opcode.SET_8, Set.as(Set.wireFormat8).fromBuffer],
+  [Opcode.SET_16, Set.as(Set.wireFormat16).fromBuffer],
+  [Opcode.SET_32, Set.as(Set.wireFormat32).fromBuffer],
+  [Opcode.SET_64, Set.as(Set.wireFormat64).fromBuffer],
+  [Opcode.SET_128, Set.as(Set.wireFormat128).fromBuffer],
+  [Opcode.SET_FF, Set.as(Set.wireFormatFF).fromBuffer],
+  [Opcode.MOV_8, Mov.as(Mov.wireFormat8).fromBuffer],
+  [Opcode.MOV_16, Mov.as(Mov.wireFormat16).fromBuffer],
 
   // 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
+  [SLoad.opcode, Instruction.fromBuffer.bind(SLoad)], // Public Storage
+  [SStore.opcode, Instruction.fromBuffer.bind(SStore)], // Public Storage
+  [NoteHashExists.opcode, Instruction.fromBuffer.bind(NoteHashExists)], // Notes & Nullifiers
+  [EmitNoteHash.opcode, Instruction.fromBuffer.bind(EmitNoteHash)], // Notes & Nullifiers
+  [NullifierExists.opcode, Instruction.fromBuffer.bind(NullifierExists)], // Notes & Nullifiers
+  [EmitNullifier.opcode, Instruction.fromBuffer.bind(EmitNullifier)], // Notes & Nullifiers
+  [L1ToL2MessageExists.opcode, Instruction.fromBuffer.bind(L1ToL2MessageExists)], // Messages
 
   // Accrued Substate
-  [EmitUnencryptedLog.opcode, Instruction.deserialize.bind(EmitUnencryptedLog)],
-  [SendL2ToL1Message.opcode, Instruction.deserialize.bind(SendL2ToL1Message)],
-  [GetContractInstance.opcode, Instruction.deserialize.bind(GetContractInstance)],
+  [EmitUnencryptedLog.opcode, Instruction.fromBuffer.bind(EmitUnencryptedLog)],
+  [SendL2ToL1Message.opcode, Instruction.fromBuffer.bind(SendL2ToL1Message)],
+  [GetContractInstance.opcode, Instruction.fromBuffer.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],
+  [Call.opcode, Instruction.fromBuffer.bind(Call)],
+  [StaticCall.opcode, Instruction.fromBuffer.bind(StaticCall)],
+  [Return.opcode, Instruction.fromBuffer.bind(Return)],
+  [Opcode.REVERT_8, Revert.as(Revert.wireFormat8).fromBuffer],
+  [Opcode.REVERT_16, Revert.as(Revert.wireFormat16).fromBuffer],
 
   // Misc
-  [DebugLog.opcode, Instruction.deserialize.bind(DebugLog)],
+  [DebugLog.opcode, Instruction.fromBuffer.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)],
+  [EcAdd.opcode, Instruction.fromBuffer.bind(EcAdd)],
+  [Poseidon2.opcode, Instruction.fromBuffer.bind(Poseidon2)],
+  [Sha256Compression.opcode, Instruction.fromBuffer.bind(Sha256Compression)],
+  [KeccakF1600.opcode, Instruction.fromBuffer.bind(KeccakF1600)],
 
   // Conversions
-  [ToRadixBE.opcode, Instruction.deserialize.bind(ToRadixBE)],
+  [ToRadixBE.opcode, Instruction.fromBuffer.bind(ToRadixBE)],
 ]);
 
 /**
  * Serializes an array of instructions to bytecode.
  */
-export function encodeToBytecode(instructions: Serializable[]): Buffer {
-  return Buffer.concat(instructions.map(i => i.serialize()));
+export function encodeToBytecode(instructions: Bufferable[]): Buffer {
+  return serializeToBuffer(instructions);
 }
 
 // For testing only

package/src/{common → public}/debug_fn_name.ts

@@ -2,7 +2,7 @@ import type { Fr } from '@aztec/foundation/fields';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { PublicContractsDBInterface } from '../public/db_interfaces.js';
+import type { PublicContractsDBInterface } from './db_interfaces.js';
 
 export async function getPublicFunctionDebugName(
   db: PublicContractsDBInterface,

package/src/public/fixtures/index.ts

@@ -1,2 +1,3 @@
 export * from './public_tx_simulation_tester.js';
 export * from './utils.js';
+export * from './simple_contract_data_source.js';

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -10,11 +10,11 @@ import { NativeWorldStateService } from '@aztec/world-state';
 
 import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
 import { DEFAULT_BLOCK_NUMBER, getContractFunctionAbi, getFunctionSelector } from '../avm/fixtures/index.js';
-import { SimpleContractDataSource } from '../avm/fixtures/simple_contract_data_source.js';
-import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
+import { PublicContractsDB } from '../public_db_sources.js';
 import { MeasuredPublicTxSimulator } from '../public_tx_simulator/measured_public_tx_simulator.js';
 import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
 import { TestExecutorMetrics } from '../test_executor_metrics.js';
+import { SimpleContractDataSource } from './simple_contract_data_source.js';
 import { createTxForPublicCalls } from './utils.js';
 
 const TIMESTAMP = new Fr(99833);
@@ -47,11 +47,9 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   ) {
     super(contractDataSource, merkleTree);
 
-    const treesDB = new PublicTreesDB(merkleTree);
     const contractsDB = new PublicContractsDB(contractDataSource);
-
     this.simulator = new MeasuredPublicTxSimulator(
-      treesDB,
+      merkleTree,
       contractsDB,
       globals,
       /*doMerkleOperations=*/ true,

package/src/public/{avm/fixtures → fixtures}/simple_contract_data_source.ts

@@ -4,7 +4,7 @@ import type { ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
-import { getFunctionSelector } from './index.js';
+import { getFunctionSelector } from '../avm/fixtures/index.js';
 
 /**
  * This class is used during public/avm testing to function as a database of

package/src/public/hinting_db_sources.ts

@@ -24,9 +24,11 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import {
   AppendOnlyTreeSnapshot,
+  type BatchInsertionResult,
   type IndexedTreeId,
   MerkleTreeId,
   type MerkleTreeLeafType,
+  type MerkleTreeWriteOperations,
   NullifierLeaf,
   NullifierLeafPreimage,
   PublicDataTreeLeaf,
@@ -35,11 +37,11 @@ import {
   getTreeName,
   merkleTreeIds,
 } from '@aztec/stdlib/trees';
+import { TreeSnapshots } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
 import type { PublicContractsDBInterface } from './db_interfaces.js';
-import { PublicTreesDB } from './public_db_sources.js';
 
 /**
  * A public contracts database that forwards requests and collects AVM hints.
@@ -101,10 +103,10 @@ export class HintingPublicContractsDB implements PublicContractsDBInterface {
 }
 
 /**
- * A public trees database that forwards requests and collects AVM hints.
+ * A low-level merkle DB that collects hints.
  */
-export class HintingPublicTreesDB extends PublicTreesDB {
-  private static readonly log: Logger = createLogger('HintingPublicTreesDB');
+export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
+  private static readonly log: Logger = createLogger('simulator:hinting-merkle-db');
   // This stack is only for debugging purposes.
   // The top of the stack is the current checkpoint id.
   // We need the stack to be non-empty and use 0 as an arbitrary initial checkpoint id.
@@ -113,19 +115,31 @@ export class HintingPublicTreesDB extends PublicTreesDB {
   private nextCheckpointId: number = 1;
   private checkpointActionCounter: number = 0; // yes, a side-effect counter.
 
-  constructor(db: PublicTreesDB, private hints: AvmExecutionHints) {
-    super(db);
+  public static async create(db: MerkleTreeWriteOperations, hints: AvmExecutionHints) {
+    const hintingTreesDB = new HintingMerkleWriteOperations(db, hints);
+    const startStateReference = await db.getStateReference();
+    hints.startingTreeRoots = new TreeSnapshots(
+      startStateReference.l1ToL2MessageTree,
+      startStateReference.partial.noteHashTree,
+      startStateReference.partial.nullifierTree,
+      startStateReference.partial.publicDataTree,
+    );
+
+    return hintingTreesDB;
   }
 
+  // Use create() to instantiate.
+  private constructor(private db: MerkleTreeWriteOperations, private hints: AvmExecutionHints) {}
+
   // Getters.
-  public override async getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>> {
-    const path = await super.getSiblingPath<N>(treeId, index);
+  public async getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>> {
+    const path = await this.db.getSiblingPath<N>(treeId, index);
     const key = await this.getHintKey(treeId);
     this.hints.getSiblingPathHints.push(new AvmGetSiblingPathHint(key, treeId, index, path.toFields()));
     return Promise.resolve(path);
   }
 
-  public override async getPreviousValueIndex<ID extends IndexedTreeId>(
+  public async getPreviousValueIndex<ID extends IndexedTreeId>(
     treeId: ID,
     value: bigint,
   ): Promise<
@@ -135,7 +149,7 @@ export class HintingPublicTreesDB extends PublicTreesDB {
       }
     | undefined
   > {
-    const result = await super.getPreviousValueIndex(treeId, value);
+    const result = await this.db.getPreviousValueIndex(treeId, value);
     if (result === undefined) {
       throw new Error(
         `getPreviousValueIndex(${getTreeName(
@@ -150,11 +164,11 @@ export class HintingPublicTreesDB extends PublicTreesDB {
     return result;
   }
 
-  public override async getLeafPreimage<ID extends IndexedTreeId>(
+  public async getLeafPreimage<ID extends IndexedTreeId>(
     treeId: ID,
     index: bigint,
   ): Promise<IndexedTreeLeafPreimage | undefined> {
-    const preimage = await super.getLeafPreimage<ID>(treeId, index);
+    const preimage = await this.db.getLeafPreimage<ID>(treeId, index);
     if (preimage) {
       const key = await this.getHintKey(treeId);
 
@@ -179,14 +193,14 @@ export class HintingPublicTreesDB extends PublicTreesDB {
     return preimage;
   }
 
-  public override async getLeafValue<ID extends MerkleTreeId>(
+  public async getLeafValue<ID extends MerkleTreeId>(
     treeId: ID,
     index: bigint,
   ): Promise<MerkleTreeLeafType<typeof treeId> | undefined> {
     // Use getLeafPreimage for PublicDataTree and NullifierTree.
     assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
 
-    const value = await super.getLeafValue<ID>(treeId, index);
+    const value = await this.db.getLeafValue<ID>(treeId, index);
     if (value) {
       const key = await this.getHintKey(treeId);
       // We can cast to Fr because we know the type of the tree.
@@ -199,7 +213,7 @@ export class HintingPublicTreesDB extends PublicTreesDB {
   // State modification.
   // FIXME(fcarreiro): This is a horrible interface (in the merkle ops). It's receiving the leaves as buffers,
   // from a leaf class that is NOT the one that will be used to write. Make this type safe.
-  public override async sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(
+  public async sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(
     treeId: ID,
     leaves: Buffer[],
   ): Promise<SequentialInsertionResult<TreeHeight>> {
@@ -210,11 +224,10 @@ export class HintingPublicTreesDB extends PublicTreesDB {
 
     const beforeState = await this.getHintKey(treeId);
 
-    const result = await super.sequentialInsert<TreeHeight, ID>(treeId, leaves);
+    const result = await this.db.sequentialInsert<TreeHeight, ID>(treeId, leaves);
 
     const afterState = await this.getHintKey(treeId);
-    HintingPublicTreesDB.log.debug('[sequentialInsert] Evolved tree state.');
-    HintingPublicTreesDB.logTreeChange(beforeState, afterState, treeId);
+    HintingMerkleWriteOperations.logTreeChange('sequentialInsert', beforeState, afterState, treeId);
 
     switch (treeId) {
       case MerkleTreeId.PUBLIC_DATA_TREE:
@@ -265,53 +278,57 @@ export class HintingPublicTreesDB extends PublicTreesDB {
     return result;
   }
 
-  public override async appendLeaves<ID extends MerkleTreeId>(
-    treeId: ID,
-    leaves: MerkleTreeLeafType<ID>[],
-  ): Promise<void> {
+  public async appendLeaves<ID extends MerkleTreeId>(treeId: ID, leaves: MerkleTreeLeafType<ID>[]): Promise<void> {
     // Use sequentialInsert for PublicDataTree and NullifierTree.
     assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
 
     // We need to process each leaf individually because we need the sibling path after insertion, to be able to constraint the insertion.
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13380): This can be changed if the world state appendLeaves returns the sibling paths.
-    for (const leaf of leaves) {
-      await this.appendLeafInternal(treeId, leaf);
+    if (leaves.length === 1) {
+      await this.appendLeafInternal(treeId, leaves[0]);
+      return;
+    } else {
+      // TODO(dbanks12): NON-HINTING! We skip hinting here for now because:
+      // 1. We only ever append multiple leaves (for now) when padding (all empty leaves).
+      // 2. We don't need hints per-item when padding.
+      // 3. In order to get per-item hints today, you need to append one-at-a-time (mentioned above), which is VERY slow.
+      await this.db.appendLeaves<ID>(treeId, leaves);
     }
   }
 
-  public override async createCheckpoint(): Promise<void> {
+  public async createCheckpoint(): Promise<void> {
     const actionCounter = this.checkpointActionCounter++;
     const oldCheckpointId = this.getCurrentCheckpointId();
     const treesStateHash = await this.getTreesStateHash();
 
-    await super.createCheckpoint();
+    await this.db.createCheckpoint();
     this.checkpointStack.push(this.nextCheckpointId++);
     const newCheckpointId = this.getCurrentCheckpointId();
 
     this.hints.createCheckpointHints.push(new AvmCreateCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId));
 
-    HintingPublicTreesDB.log.debug(
+    HintingMerkleWriteOperations.log.trace(
       `[createCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`,
     );
   }
 
-  public override async commitCheckpoint(): Promise<void> {
+  public async commitCheckpoint(): Promise<void> {
     const actionCounter = this.checkpointActionCounter++;
     const oldCheckpointId = this.getCurrentCheckpointId();
     const treesStateHash = await this.getTreesStateHash();
 
-    await super.commitCheckpoint();
+    await this.db.commitCheckpoint();
     this.checkpointStack.pop();
     const newCheckpointId = this.getCurrentCheckpointId();
 
     this.hints.commitCheckpointHints.push(new AvmCommitCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId));
 
-    HintingPublicTreesDB.log.debug(
+    HintingMerkleWriteOperations.log.trace(
       `[commitCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`,
     );
   }
 
-  public override async revertCheckpoint(): Promise<void> {
+  public async revertCheckpoint(): Promise<void> {
     const actionCounter = this.checkpointActionCounter++;
     const oldCheckpointId = this.getCurrentCheckpointId();
     const treesStateHash = await this.getTreesStateHash();
@@ -324,7 +341,7 @@ export class HintingPublicTreesDB extends PublicTreesDB {
       [MerkleTreeId.ARCHIVE]: await this.getHintKey(MerkleTreeId.ARCHIVE),
     };
 
-    await super.revertCheckpoint();
+    await this.db.revertCheckpoint();
     this.checkpointStack.pop();
     const newCheckpointId = this.getCurrentCheckpointId();
 
@@ -340,17 +357,17 @@ export class HintingPublicTreesDB extends PublicTreesDB {
       AvmRevertCheckpointHint.create(actionCounter, oldCheckpointId, newCheckpointId, beforeState, afterState),
     );
 
-    HintingPublicTreesDB.log.debug(
+    HintingMerkleWriteOperations.log.trace(
       `[revertCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`,
     );
     for (const treeId of merkleTreeIds()) {
-      HintingPublicTreesDB.logTreeChange(beforeState[treeId], afterState[treeId], treeId);
+      HintingMerkleWriteOperations.logTreeChange('revertCheckpoint', beforeState[treeId], afterState[treeId], treeId);
     }
   }
 
   // Private methods.
   private async getHintKey(treeId: MerkleTreeId): Promise<AppendOnlyTreeSnapshot> {
-    const treeInfo = await super.getTreeInfo(treeId);
+    const treeInfo = await this.db.getTreeInfo(treeId);
     return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
   }
 
@@ -360,18 +377,19 @@ export class HintingPublicTreesDB extends PublicTreesDB {
 
   // For logging/debugging purposes.
   private async getTreesStateHash(): Promise<Fr> {
-    const stateReferenceFields = (await super.getStateReference()).toFields();
+    const stateReferenceFields = (await this.db.getStateReference()).toFields();
     return Fr.fromBuffer(sha256Trunc(Buffer.concat(stateReferenceFields.map(field => field.toBuffer()))));
   }
 
   private static logTreeChange(
+    action: string,
     beforeState: AppendOnlyTreeSnapshot,
     afterState: AppendOnlyTreeSnapshot,
     treeId: MerkleTreeId,
   ) {
     const treeName = getTreeName(treeId);
-    HintingPublicTreesDB.log.debug(
-      `[${treeName}] Evolved tree state: ${beforeState.root}, ${beforeState.nextAvailableLeafIndex} -> ${afterState.root}, ${afterState.nextAvailableLeafIndex}.`,
+    HintingMerkleWriteOperations.log.trace(
+      `[${action}] ${treeName} tree state: ${beforeState.root}, ${beforeState.nextAvailableLeafIndex} -> ${afterState.root}, ${afterState.nextAvailableLeafIndex}.`,
     );
   }
 
@@ -384,15 +402,69 @@ export class HintingPublicTreesDB extends PublicTreesDB {
 
     const beforeState = await this.getHintKey(treeId);
 
-    await super.appendLeaves<ID>(treeId, [leaf]);
+    await this.db.appendLeaves<ID>(treeId, [leaf]);
 
     const afterState = await this.getHintKey(treeId);
 
-    HintingPublicTreesDB.log.debug('[appendLeaves] Evolved tree state.');
-    HintingPublicTreesDB.logTreeChange(beforeState, afterState, treeId);
+    HintingMerkleWriteOperations.logTreeChange('appendLeaves', beforeState, afterState, treeId);
 
     this.hints.appendLeavesHints.push(new AvmAppendLeavesHint(beforeState, afterState, treeId, [leaf as Fr]));
 
     return await this.getSiblingPath<N>(treeId, BigInt(beforeState.nextAvailableLeafIndex));
   }
+
+  // Non-hinted required methods from MerkleTreeWriteOperations interface
+  public async getTreeInfo(treeId: MerkleTreeId) {
+    return await this.db.getTreeInfo(treeId);
+  }
+
+  public async getStateReference() {
+    return await this.db.getStateReference();
+  }
+
+  public getInitialHeader() {
+    return this.db.getInitialHeader();
+  }
+
+  public async updateArchive(header: any): Promise<void> {
+    return await this.db.updateArchive(header);
+  }
+
+  public async batchInsert<
+    TreeHeight extends number,
+    SubtreeSiblingPathHeight extends number,
+    ID extends IndexedTreeId,
+  >(
+    treeId: ID,
+    leaves: Buffer[],
+    subtreeHeight: number,
+  ): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>> {
+    return await this.db.batchInsert<TreeHeight, SubtreeSiblingPathHeight, ID>(treeId, leaves, subtreeHeight);
+  }
+
+  public async close(): Promise<void> {
+    return await this.db.close();
+  }
+
+  public async findLeafIndices<ID extends MerkleTreeId>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+  ): Promise<(bigint | undefined)[]> {
+    return await this.db.findLeafIndices(treeId, values);
+  }
+
+  public async findLeafIndicesAfter<ID extends MerkleTreeId>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+    startIndex: bigint,
+  ): Promise<(bigint | undefined)[]> {
+    return await this.db.findLeafIndicesAfter(treeId, values, startIndex);
+  }
+
+  public async getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(
+    treeId: ID,
+    leafIndices: bigint[],
+  ): Promise<(bigint | undefined)[]> {
+    return await this.db.getBlockNumbersForLeafIndices(treeId, leafIndices);
+  }
 }

package/src/public/index.ts

@@ -1,8 +1,4 @@
-export * from './db_interfaces.js';
-export * from './public_tx_simulator/index.js';
-export * from './public_db_sources.js';
+export { PublicContractsDB } from './public_db_sources.js';
+export { type PublicTxResult, PublicTxSimulator, TelemetryPublicTxSimulator } from './public_tx_simulator/index.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
-export { SideEffectTrace } from './side_effect_trace.js';
-export { PublicTxSimulationTester } from './fixtures/index.js';
-export * from './avm/index.js';
 export { getCallRequestsWithCalldataByPhase } from './utils.js';