@aztec/simulator 0.87.7 → 1.0.0-nightly.20250605

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

@@ -16,7 +16,7 @@ export class Jump extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     context.machineState.pc = this.jumpOffset;
   }
@@ -50,7 +50,9 @@ export class JumpI extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.condOffset];
     const [condOffset] = addressing.resolve(operands, memory);
@@ -79,7 +81,7 @@ export class InternalCall extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     context.machineState.internalCallStack.push({
       callPc: context.machineState.pc,
@@ -104,7 +106,7 @@ export class InternalReturn extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     const stackEntry = context.machineState.internalCallStack.pop();
     if (stackEntry === undefined) {

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

@@ -35,6 +35,10 @@ export class ToRadixBE extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.srcOffset, this.radixOffset, this.numLimbsOffset, this.outputBitsOffset, this.dstOffset];
     const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
 
@@ -45,11 +49,13 @@ export class ToRadixBE extends Instruction {
     memory.checkTag(TypeTag.UINT1, outputBitsOffset);
 
     const numLimbs = memory.get(numLimbsOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(numLimbs));
+    const radix: bigint = memory.get(radixOffset).toBigInt();
+    context.machineState.consumeGas(
+      this.dynamicGasCost(Math.max(numLimbs, radix > 256n ? 32 : MODULUS_LIMBS_PER_RADIX[Number(radix)])),
+    );
     const outputBits = memory.get(outputBitsOffset).toNumber();
 
     let value: bigint = memory.get(srcOffset).toBigInt();
-    const radix: bigint = memory.get(radixOffset).toBigInt();
 
     if (radix < 2 || radix > 256) {
       throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
@@ -79,3 +85,16 @@ export class ToRadixBE extends Instruction {
     memory.setSlice(dstOffset, res);
   }
 }
+
+// First two are for radix = 0 and 1, which are invalid, so we have 0 limbs for those cases.
+export const MODULUS_LIMBS_PER_RADIX: number[] = [
+  0, 0, 254, 161, 127, 110, 99, 91, 85, 81, 77, 74, 71, 69, 67, 65, 64, 63, 61, 60, 59, 58, 57, 57, 56, 55, 54, 54, 53,
+  53, 52, 52, 51, 51, 50, 50, 50, 49, 49, 48, 48, 48, 48, 47, 47, 47, 46, 46, 46, 46, 45, 45, 45, 45, 45, 44, 44, 44,
+  44, 44, 43, 43, 43, 43, 43, 43, 42, 42, 42, 42, 42, 42, 42, 41, 41, 41, 41, 41, 41, 41, 41, 41, 40, 40, 40, 40, 40,
+  40, 40, 40, 40, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+  37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+  36, 36, 36, 36, 36, 36, 36, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
+  35, 35, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
+  34, 34, 34, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+  33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+];

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

@@ -41,7 +41,9 @@ export class EcAdd extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [
       this.p1XOffset,

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

@@ -73,7 +73,9 @@ export class GetEnvVar extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     if (!(this.varEnum in EnvironmentVariable)) {
       throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${this.varEnum}`);

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

@@ -32,11 +32,15 @@ abstract class ExternalCall extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.l2GasOffset, this.daGasOffset, this.addrOffset, this.argsSizeOffset, this.argsOffset];
     const [l2GasOffset, daGasOffset, addrOffset, argsSizeOffset, argsOffset] = addressing.resolve(operands, memory);
-    // TODO: Should be U32
-    memory.checkTags(TypeTag.FIELD, l2GasOffset);
-    memory.checkTags(TypeTag.FIELD, daGasOffset);
+
+    memory.checkTags(TypeTag.UINT32, l2GasOffset);
+    memory.checkTags(TypeTag.UINT32, daGasOffset);
     memory.checkTag(TypeTag.FIELD, addrOffset);
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
 
@@ -48,9 +52,7 @@ abstract class ExternalCall extends Instruction {
     // If we are already in a static call, we propagate the environment.
     const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
 
-    // First we consume the gas for this operation.
-    context.machineState.consumeGas(this.gasCost(calldataSize));
-    // Then we consume the gas allocated for the nested call. The excess will be refunded later.
+    // We consume the gas allocated for the nested call. The excess will be refunded later.
     // Gas allocation is capped by the amount of gas left in the current context.
     // We have to do some dancing here because the gas allocation is a field,
     // but in the machine state we track gas as a number.
@@ -179,12 +181,15 @@ export class Return extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.returnSizeOffset, this.returnOffset];
     const [returnSizeOffset, returnOffset] = addressing.resolve(operands, memory);
 
     memory.checkTag(TypeTag.UINT32, returnSizeOffset);
     const returnSize = memory.get(returnSizeOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(returnSize));
 
     const output = memory.getSlice(returnOffset, returnSize).map(word => word.toFr());
 
@@ -225,12 +230,15 @@ export class Revert extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.retSizeOffset, this.returnOffset];
     const [retSizeOffset, returnOffset] = addressing.resolve(operands, memory);
 
     memory.checkTag(TypeTag.UINT32, retSizeOffset);
     const retSize = memory.get(retSizeOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(retSize));
     const output = memory.getSlice(returnOffset, retSize).map(word => word.toFr());
 
     context.machineState.revert(output);

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

@@ -31,7 +31,9 @@ export class Poseidon2 extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.inputStateOffset, this.outputStateOffset];
 
@@ -74,9 +76,12 @@ export class KeccakF1600 extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.dstOffset, this.inputOffset];
     const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
-    context.machineState.consumeGas(this.gasCost());
 
     const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
     memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
@@ -117,11 +122,14 @@ export class Sha256Compression extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.outputOffset, this.stateOffset, this.inputsOffset];
     const [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
 
     // Note: size of output is same as size of state
-    context.machineState.consumeGas(this.gasCost());
     const inputs = Uint32Array.from(memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toNumber()));
     const state = Uint32Array.from(memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toNumber()));
 

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

@@ -3,7 +3,7 @@ import type { Bufferable } from '@aztec/foundation/serialize';
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { type Gas, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { type Gas, computeAddressingCost, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
 import type { BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
 
@@ -92,13 +92,20 @@ export abstract class Instruction {
   }
 
   /**
-   * Computes gas cost for the instruction based on its base cost and memory operations.
-   * @returns Gas cost.
+   * Returns the base gas cost for the instruction.
+   * @returns The base gas cost.
    */
-  protected gasCost(dynMultiplier: number = 0): Gas {
-    const baseGasCost = getBaseGasCost(this.opcode);
-    const dynGasCost = mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
-    return sumGas(baseGasCost, dynGasCost);
+  protected baseGasCost(indirectOperandsCount: number, relativeOperandsCount: number): Gas {
+    return sumGas(getBaseGasCost(this.opcode), computeAddressingCost(indirectOperandsCount, relativeOperandsCount));
+  }
+
+  /**
+   * Computes the dynamic gas cost for the instruction
+   * @param dynMultiplier - The multiplier for the dynamic gas cost.
+   * @returns The dynamic gas cost.
+   */
+  protected dynamicGasCost(dynMultiplier: number = 0): Gas {
+    return mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
   }
 
   /**

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

@@ -68,7 +68,9 @@ export class Set extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.dstOffset];
     const [dstOffset] = addressing.resolve(operands, memory);
@@ -108,7 +110,9 @@ export class Cast extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.srcOffset, this.dstOffset];
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
@@ -151,7 +155,9 @@ export class Mov extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.srcOffset, this.dstOffset];
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
@@ -185,13 +191,17 @@ export class CalldataCopy extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.copySizeOffset, this.cdStartOffset, this.dstOffset];
     const [copySizeOffset, cdStartOffset, dstOffset] = addressing.resolve(operands, memory);
 
     memory.checkTags(TypeTag.UINT32, cdStartOffset, copySizeOffset);
     const cdStart = memory.get(cdStartOffset).toNumber();
     const copySize = memory.get(copySizeOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(copySize));
+    context.machineState.consumeGas(this.dynamicGasCost(copySize));
 
     // Values which are out-of-range of the calldata array will be set with Field(0);
     const slice = context.environment.calldata.slice(cdStart, cdStart + copySize).map(f => new Field(f));
@@ -219,9 +229,12 @@ export class ReturndataSize extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.dstOffset];
     const [dstOffset] = addressing.resolve(operands, memory);
-    context.machineState.consumeGas(this.gasCost());
 
     memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length));
   }
@@ -252,13 +265,17 @@ export class ReturndataCopy extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.copySizeOffset, this.rdStartOffset, this.dstOffset];
     const [copySizeOffset, rdStartOffset, dstOffset] = addressing.resolve(operands, memory);
 
     memory.checkTags(TypeTag.UINT32, rdStartOffset, copySizeOffset);
     const rdStart = memory.get(rdStartOffset).toNumber();
     const copySize = memory.get(copySizeOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(copySize));
+    context.machineState.consumeGas(this.dynamicGasCost(copySize));
 
     // Values which are out-of-range of the returndata array will be set with Field(0);
     const slice = context.machineState.nestedReturndata.slice(rdStart, rdStart + copySize).map(f => new Field(f));

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

@@ -35,6 +35,10 @@ export class DebugLog extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
     const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
@@ -60,9 +64,5 @@ export class DebugLog extends Instruction {
 
       DebugLog.logger.verbose(formattedStr);
     }
-
-    // Despite having dynamic "size" operands, the gas cost is fixed because
-    // this opcode is a no-op except during client-initiated simulation
-    context.machineState.consumeGas(this.gasCost());
   }
 }

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

@@ -39,14 +39,22 @@ export class SStore extends BaseStorageInstruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset];
     const [srcOffset, slotOffset] = addressing.resolve(operands, memory);
+    // We read before tag checking since it's needed for gas cost calculation
+    const slot = memory.get(slotOffset).toFr();
+
+    context.machineState.consumeGas(
+      this.dynamicGasCost(Number(context.persistableState.isStorageCold(context.environment.address, slot))),
+    );
+
     memory.checkTag(TypeTag.FIELD, slotOffset);
     memory.checkTag(TypeTag.FIELD, srcOffset);
 
-    const slot = memory.get(slotOffset).toFr();
     const value = memory.get(srcOffset).toFr();
     await context.persistableState.writeStorage(context.environment.address, slot, value);
   }
@@ -64,7 +72,9 @@ export class SLoad extends BaseStorageInstruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset];
     const [slotOffset, dstOffset] = addressing.resolve(operands, memory);

package/src/public/fixtures/index.ts

@@ -1,3 +1,4 @@
 export * from './public_tx_simulation_tester.js';
 export * from './utils.js';
 export * from './simple_contract_data_source.js';
+export { readAvmMinimalPublicTxInputsFromFile, createAvmMinimalPublicTx } from './minimal_public_tx.js';

package/src/public/fixtures/minimal_public_tx.ts

@@ -0,0 +1,57 @@
+import { FunctionType, emptyContractArtifact, emptyFunctionArtifact } from '@aztec/stdlib/abi';
+import { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import avmMinimalCircuitInputsJson from '../../../artifacts/avm_minimal_inputs.json' with { type: 'json' };
+import { TypeTag } from '../avm/avm_memory_types.js';
+import { Add, Return, Set } from '../avm/opcodes/index.js';
+import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
+import { Opcode } from '../avm/serialization/instruction_serialization.js';
+import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+export async function createAvmMinimalPublicTx(): Promise<PublicTxResult> {
+  const deployer = AztecAddress.fromNumber(42);
+
+  const simTester = await PublicTxSimulationTester.create();
+
+  const minimalBytecode = encodeToBytecode([
+    new Set(/*indirect*/ 0, /*dstOffset*/ 0, TypeTag.UINT32, /*value*/ 1).as(Opcode.SET_8, Set.wireFormat8),
+    new Set(/*indirect*/ 0, /*dstOffset*/ 1, TypeTag.UINT32, /*value*/ 2).as(Opcode.SET_8, Set.wireFormat8),
+    new Add(/*indirect=*/ 0, /*aOffset=*/ 0, /*bOffset=*/ 1, /*dstOffset=*/ 2).as(Opcode.ADD_8, Add.wireFormat8),
+    new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 2),
+  ]);
+
+  const minimalContractArtifact = emptyContractArtifact();
+  minimalContractArtifact.name = 'MinimalContract';
+  minimalContractArtifact.functions = [emptyFunctionArtifact()];
+  minimalContractArtifact.functions[0].name = 'public_dispatch';
+  minimalContractArtifact.functions[0].functionType = FunctionType.PUBLIC;
+  minimalContractArtifact.functions[0].bytecode = minimalBytecode;
+
+  const minimalTestContract = await simTester.registerAndDeployContract(
+    /*constructorArgs=*/ [],
+    deployer,
+    /*contractArtifact=*/ minimalContractArtifact,
+  );
+
+  return await simTester.simulateTx(
+    /*sender=*/ deployer,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: minimalTestContract.address,
+        fnName: 'public_dispatch',
+        args: [],
+      },
+    ],
+  );
+}
+
+/**
+ * Reads the AVM circuit inputs for the minimal public tx from a pre-generated JSON file.
+ * @returns The AvmCircuitInputs for the minimal public tx.
+ */
+export function readAvmMinimalPublicTxInputsFromFile(): AvmCircuitInputs {
+  return AvmCircuitInputs.schema.parse(avmMinimalCircuitInputsJson);
+}

package/src/public/fixtures/utils.ts

@@ -127,10 +127,10 @@ export async function addNewContractClassToTx(
   ];
   const contractAddress = new AztecAddress(new Fr(REGISTERER_CONTRACT_ADDRESS));
   const emittedLength = contractClassLogFields.length;
-  const log = ContractClassLogFields.fromEmittedFields(contractClassLogFields);
+  const logFields = ContractClassLogFields.fromEmittedFields(contractClassLogFields);
 
   const contractClassLogHash = LogHash.from({
-    value: await log.hash(),
+    value: await logFields.hash(),
     length: emittedLength,
   }).scope(contractAddress);
 
@@ -143,7 +143,7 @@ export async function addNewContractClassToTx(
   const nextLogIndex = countAccumulatedItems(accumulatedData.contractClassLogsHashes);
   accumulatedData.contractClassLogsHashes[nextLogIndex] = contractClassLogHash;
 
-  tx.contractClassLogs.push(log);
+  tx.contractClassLogFields.push(logFields);
 }
 
 export async function addNewContractInstanceToTx(

package/src/public/hinting_db_sources.ts

@@ -318,6 +318,14 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
     );
   }
 
+  public commitAllCheckpoints(): Promise<void> {
+    throw new Error('commitAllCheckpoints is not supported in HintingMerkleWriteOperations.');
+  }
+
+  public revertAllCheckpoints(): Promise<void> {
+    throw new Error('revertAllCheckpoints is not supported in HintingMerkleWriteOperations.');
+  }
+
   public async commitCheckpoint(): Promise<void> {
     const actionCounter = this.checkpointActionCounter++;
     const oldCheckpointId = this.getCurrentCheckpointId();
@@ -459,6 +467,13 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
     return await this.db.findLeafIndices(treeId, values);
   }
 
+  public async findSiblingPaths<ID extends MerkleTreeId, N extends number>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+  ): Promise<(SiblingPath<N> | undefined)[]> {
+    return await this.db.findSiblingPaths(treeId, values);
+  }
+
   public async findLeafIndicesAfter<ID extends MerkleTreeId>(
     treeId: ID,
     values: MerkleTreeLeafType<ID>[],

package/src/public/index.ts

@@ -1,4 +1,5 @@
 export { PublicContractsDB } from './public_db_sources.js';
-export { type PublicTxResult, PublicTxSimulator, TelemetryPublicTxSimulator } from './public_tx_simulator/index.js';
+export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_tree.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
+export { PublicTxSimulator, TelemetryPublicTxSimulator, type PublicTxResult } from './public_tx_simulator/index.js';
 export { getCallRequestsWithCalldataByPhase } from './utils.js';

package/src/public/public_db_sources.ts

@@ -89,12 +89,8 @@ export class PublicContractsDB implements PublicContractsDBInterface {
    */
   private async addNonRevertibleContractClasses(tx: Tx) {
     const siloedContractClassLogs = tx.data.forPublic
-      ? await tx.filterContractClassLogs(
-          tx.data.forPublic!.nonRevertibleAccumulatedData.contractClassLogsHashes,
-          /*siloed=*/ true,
-        )
-      : await tx.filterContractClassLogs(tx.data.forRollup!.end.contractClassLogsHashes, /*siloed=*/ true);
-
+      ? tx.getSplitContractClassLogs(false /* revertible */)
+      : tx.getContractClassLogs();
     await this.addContractClassesFromLogs(siloedContractClassLogs, this.currentTxNonRevertibleCache, 'non-revertible');
   }
 
@@ -104,13 +100,7 @@ export class PublicContractsDB implements PublicContractsDBInterface {
    * @param tx - The transaction to add revertible contract classes from.
    */
   private async addRevertibleContractClasses(tx: Tx) {
-    const siloedContractClassLogs = tx.data.forPublic
-      ? await tx.filterContractClassLogs(
-          tx.data.forPublic!.revertibleAccumulatedData.contractClassLogsHashes,
-          /*siloed=*/ true,
-        )
-      : [];
-
+    const siloedContractClassLogs = tx.data.forPublic ? tx.getSplitContractClassLogs(true /* revertible */) : [];
     await this.addContractClassesFromLogs(siloedContractClassLogs, this.currentTxRevertibleCache, 'revertible');
   }