@aztec/bb-prover 0.71.0 → 0.72.1

package/src/bb/cli.ts

@@ -5,11 +5,6 @@ import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { Command } from 'commander';
-import { promises as fs } from 'fs';
-
-import { generateContractForCircuit, generateKeyForNoirCircuit } from './execute.js';
-
-const { BB_WORKING_DIRECTORY, BB_BINARY_PATH } = process.env;
 
 export const ProtocolCircuitArtifacts: Record<ProtocolArtifact, NoirCompiledCircuit> = {
   ...ClientCircuitArtifacts,
@@ -33,76 +28,5 @@ export function getProgram(log: LogFn): Command {
       log(Object.keys(ProtocolCircuitArtifacts).reduce((prev: string, x: string) => prev.concat(`\n${x}`)));
     });
 
-  program
-    .command('write-vk')
-    .description('Generates the verification key for the specified circuit')
-    .requiredOption(
-      '-w, --working-directory <string>',
-      'A directory to use for storing input/output files',
-      BB_WORKING_DIRECTORY,
-    )
-    .requiredOption('-b, --bb-path <string>', 'The path to the BB binary', BB_BINARY_PATH)
-    .requiredOption('-c, --circuit <string>', 'The name of a protocol circuit')
-    .requiredOption('-f, --flavor <string>', 'The name of the verification key flavor', 'ultra_honk')
-    .option('-r, --recursive', 'Whether a SNARK friendly key should be generated', false)
-    .action(async options => {
-      const compiledCircuit = ProtocolCircuitArtifacts[options.circuit as ProtocolArtifact];
-      if (!compiledCircuit) {
-        log(`Failed to find circuit ${options.circuit}`);
-        return;
-      }
-      try {
-        await fs.access(options.workingDirectory, fs.constants.W_OK);
-      } catch (error) {
-        log(`Working directory does not exist`);
-        return;
-      }
-      await generateKeyForNoirCircuit(
-        options.bbPath,
-        options.workingDirectory,
-        options.circuit,
-        compiledCircuit,
-        options.recursive,
-        options.flavor,
-        // (options.circuit as ServerProtocolArtifact) === 'RootRollupArtifact' ? 'ultra_keccak_honk' : 'ultra_honk',
-        log,
-      );
-    });
-
-  program
-    .command('write-contract')
-    .description('Generates the verification contract for the specified circuit')
-    .requiredOption(
-      '-w, --working-directory <string>',
-      'A directory to use for storing input/output files',
-      BB_WORKING_DIRECTORY,
-    )
-    .requiredOption('-b, --bb-path <string>', 'The path to the BB binary', BB_BINARY_PATH)
-    .requiredOption('-c, --circuit <string>', 'The name of a protocol circuit')
-    .requiredOption('-n --contract-name <string>', 'The name of the contract to generate', 'contract.sol')
-    .action(async options => {
-      const compiledCircuit = ProtocolCircuitArtifacts[options.circuit as ProtocolArtifact];
-      if (!compiledCircuit) {
-        log(`Failed to find circuit ${options.circuit}`);
-        return;
-      }
-      try {
-        await fs.access(options.workingDirectory, fs.constants.W_OK);
-      } catch (error) {
-        log(`Working directory does not exist`);
-        return;
-      }
-
-      await generateContractForCircuit(
-        options.bbPath,
-        options.workingDirectory,
-        options.circuit,
-        compiledCircuit,
-        options.contractName,
-        log,
-        /*force= */ true,
-      );
-    });
-
   return program;
 }

package/src/bb/execute.ts

@@ -2,7 +2,6 @@ import { type AvmCircuitInputs, serializeWithMessagePack } from '@aztec/circuits
 import { sha256 } from '@aztec/foundation/crypto';
 import { type LogFn, type Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
@@ -97,103 +96,6 @@ export function executeBB(
   }).catch(_ => ({ status: BB_RESULT.FAILURE, exitCode: -1, signal: undefined }));
 }
 
-const bytecodeFilename = 'bytecode';
-
-/**
- * Used for generating either a proving or verification key, will exit early if the key already exists
- * It assumes the provided working directory is one where the caller wishes to maintain a permanent set of keys
- * It is not considered a temporary directory
- * @param pathToBB - The full path to the bb binary
- * @param workingDirectory - The directory into which the key should be created
- * @param circuitName - An identifier for the circuit
- * @param compiledCircuit - The compiled circuit
- * @param key - The type of key, either 'pk' or 'vk'
- * @param log - A logging function
- * @param force - Force the key to be regenerated even if it already exists
- * @returns An instance of BBResult
- */
-export async function generateKeyForNoirCircuit(
-  pathToBB: string,
-  workingDirectory: string,
-  circuitName: string,
-  compiledCircuit: NoirCompiledCircuit,
-  recursive: boolean,
-  flavor: UltraHonkFlavor,
-  log: LogFn,
-  force = false,
-): Promise<BBSuccess | BBFailure> {
-  const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
-
-  // The key generation is written to e.g. /workingDirectory/pk/BaseParityArtifact/pk
-  // The bytecode hash file is also written here as /workingDirectory/pk/BaseParityArtifact/bytecode-hash
-  // The bytecode is written to e.g. /workingDirectory/pk/BaseParityArtifact/bytecode
-  // The bytecode is removed after the key is generated, leaving just the hash file
-  const circuitOutputDirectory = `${workingDirectory}/vk/${circuitName}`;
-  const outputPath = `${circuitOutputDirectory}`;
-  const bytecodeHash = sha256(bytecode);
-
-  // ensure the directory exists
-  await fs.mkdir(circuitOutputDirectory, { recursive: true });
-
-  const res = await fsCache<BBSuccess | BBFailure>(circuitOutputDirectory, bytecodeHash, log, force, async () => {
-    const binaryPresent = await fs
-      .access(pathToBB, fs.constants.R_OK)
-      .then(_ => true)
-      .catch(_ => false);
-    if (!binaryPresent) {
-      return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
-    }
-
-    // We are now going to generate the key
-    try {
-      const bytecodePath = `${circuitOutputDirectory}/${bytecodeFilename}`;
-      // Write the bytecode to the working directory
-      await fs.writeFile(bytecodePath, bytecode);
-
-      // args are the output path and the input bytecode path
-      const args = ['-o', `${outputPath}/${VK_FILENAME}`, '-b', bytecodePath, recursive ? '--recursive' : ''];
-      const timer = new Timer();
-      let result = await executeBB(pathToBB, `write_vk_${flavor}`, args, log);
-
-      // If we succeeded and the type of key if verification, have bb write the 'fields' version too
-      if (result.status == BB_RESULT.SUCCESS) {
-        const asFieldsArgs = ['-k', `${outputPath}/${VK_FILENAME}`, '-o', `${outputPath}/${VK_FIELDS_FILENAME}`, '-v'];
-        result = await executeBB(pathToBB, `vk_as_fields_${flavor}`, asFieldsArgs, log);
-      }
-      const duration = timer.ms();
-
-      if (result.status == BB_RESULT.SUCCESS) {
-        return {
-          status: BB_RESULT.SUCCESS,
-          durationMs: duration,
-          pkPath: undefined,
-          vkPath: outputPath,
-          proofPath: undefined,
-        };
-      }
-      // Not a great error message here but it is difficult to decipher what comes from bb
-      return {
-        status: BB_RESULT.FAILURE,
-        reason: `Failed to generate key. Exit code: ${result.exitCode}. Signal ${result.signal}.`,
-        retry: !!result.signal,
-      };
-    } catch (error) {
-      return { status: BB_RESULT.FAILURE, reason: `${error}` };
-    }
-  });
-
-  if (!res) {
-    return {
-      status: BB_RESULT.ALREADY_PRESENT,
-      durationMs: 0,
-      pkPath: undefined,
-      vkPath: outputPath,
-    };
-  }
-
-  return res;
-}
-
 // TODO(#7369) comment this etc (really just take inspiration from this and rewrite it all O:))
 export async function executeBbClientIvcProof(
   pathToBB: string,
@@ -960,43 +862,6 @@ export async function generateContractForVerificationKey(
   return res;
 }
 
-export async function generateContractForCircuit(
-  pathToBB: string,
-  workingDirectory: string,
-  circuitName: string,
-  compiledCircuit: NoirCompiledCircuit,
-  contractName: string,
-  log: LogFn,
-  force = false,
-) {
-  // Verifier contracts are never recursion friendly, because non-recursive proofs are generated using the keccak256 hash function.
-  // We need to use the same hash function during verification so proofs generated using keccak256 are cheap to verify on ethereum
-  // (where the verifier contract would be deployed) whereas if we want to verify the proof within a snark (for recursion) we want
-  // to use a snark-friendly hash function.
-  const recursive = false;
-
-  const vkResult = await generateKeyForNoirCircuit(
-    pathToBB,
-    workingDirectory,
-    circuitName,
-    compiledCircuit,
-    recursive,
-    'ultra_keccak_honk',
-    log,
-    force,
-  );
-  if (vkResult.status === BB_RESULT.FAILURE) {
-    return vkResult;
-  }
-
-  return generateContractForVerificationKey(
-    pathToBB,
-    join(vkResult.vkPath!, VK_FILENAME),
-    join(workingDirectory, 'contract', circuitName, contractName),
-    log,
-  );
-}
-
 /**
  * Compute bb gate count for a given circuit
  * @param pathToBB - The full path to the bb binary

package/src/prover/bb_prover.ts

@@ -23,7 +23,6 @@ import {
   RecursiveProof,
   type RootParityInputs,
   TUBE_PROOF_LENGTH,
-  type VerificationKeyAsFields,
   type VerificationKeyData,
   makeRecursiveProofFromBinary,
 } from '@aztec/circuits.js';
@@ -69,6 +68,7 @@ import {
   convertSingleTxBlockRootRollupInputsToWitnessMap,
   convertSingleTxBlockRootRollupOutputsFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types/server';
+import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
 import { NativeACVMSimulator } from '@aztec/simulator/server';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
@@ -86,7 +86,6 @@ import {
   PROOF_FILENAME,
   VK_FILENAME,
   generateAvmProof,
-  generateKeyForNoirCircuit,
   generateProof,
   generateTubeProof,
   verifyAvmProof,
@@ -114,11 +113,6 @@ export interface BBProverConfig extends BBConfig, ACVMConfig {
  * Prover implementation that uses barretenberg native proving
  */
 export class BBNativeRollupProver implements ServerCircuitProver {
-  private verificationKeys = new Map<
-    `ultra${'_keccak_' | '_' | '_rollup_'}honk_${ServerProtocolArtifact}`,
-    Promise<VerificationKeyData>
-  >();
-
   private instrumentation: ProverInstrumentation;
 
   constructor(private config: BBProverConfig, telemetry: TelemetryClient) {
@@ -157,7 +151,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertBaseParityOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('BaseParityArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('BaseParityArtifact');
     await this.verifyProof('BaseParityArtifact', proof.binaryProof);
 
     return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
@@ -180,7 +174,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertRootParityOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('RootParityArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('RootParityArtifact');
     await this.verifyProof('RootParityArtifact', proof.binaryProof);
 
     return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
@@ -222,7 +216,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertPrivateBaseRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit(artifactName);
+    const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
 
     await this.verifyProof(artifactName, proof.binaryProof);
 
@@ -249,7 +243,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertPublicBaseRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit(artifactName);
+    const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
 
     await this.verifyProof(artifactName, proof.binaryProof);
 
@@ -274,7 +268,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertMergeRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
 
     await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
 
@@ -299,7 +293,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertBlockRootRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
 
     await this.verifyProof('BlockRootRollupArtifact', proof.binaryProof);
 
@@ -319,7 +313,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertSingleTxBlockRootRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
 
     await this.verifyProof('SingleTxBlockRootRollupArtifact', proof.binaryProof);
 
@@ -344,7 +338,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertEmptyBlockRootRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
 
     await this.verifyProof('EmptyBlockRootRollupArtifact', proof.binaryProof);
 
@@ -369,7 +363,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertBlockMergeRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('BlockMergeRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('BlockMergeRollupArtifact');
 
     await this.verifyProof('BlockMergeRollupArtifact', proof.binaryProof);
 
@@ -393,7 +387,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('RootRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('RootRollupArtifact');
 
     await this.verifyProof('RootRollupArtifact', proof);
 
@@ -409,7 +403,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     convertInput: (input: Input) => WitnessMap,
     convertOutput: (outputWitness: WitnessMap) => Output,
     workingDirectory: string,
-  ): Promise<{ circuitOutput: Output; vkData: VerificationKeyData; provingResult: BBSuccess }> {
+  ): Promise<{ circuitOutput: Output; provingResult: BBSuccess }> {
     // Have the ACVM write the partial witness here
     const outputWitnessFile = path.join(workingDirectory, 'partial-witness.gz');
 
@@ -462,12 +456,8 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
     }
 
-    // Ensure our vk cache is up to date
-    const vkData = await this.updateVerificationKeyAfterProof(provingResult.vkPath!, circuitType);
-
     return {
       circuitOutput: output,
-      vkData,
       provingResult,
     };
   }
@@ -479,15 +469,17 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     convertOutput: (outputWitness: WitnessMap) => Output,
   ): Promise<{ circuitOutput: Output; proof: Proof }> {
     const operation = async (bbWorkingDirectory: string) => {
-      const {
-        provingResult,
-        vkData,
-        circuitOutput: output,
-      } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+      const { provingResult, circuitOutput: output } = await this.generateProofWithBB(
+        input,
+        circuitType,
+        convertInput,
+        convertOutput,
+        bbWorkingDirectory,
+      );
 
       // Read the binary proof
       const rawProof = await fs.readFile(`${provingResult.proofPath!}/${PROOF_FILENAME}`);
-
+      const vkData = this.getVerificationKeyDataForCircuit(circuitType);
       const proof = new Proof(rawProof, vkData.numPublicInputs);
       const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
 
@@ -581,12 +573,12 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }
 
   public async getTubeProof(input: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    // this probably is gonna need to call client ivc
     const operation = async (bbWorkingDirectory: string) => {
       logger.debug(`createTubeProof: ${bbWorkingDirectory}`);
       const provingResult = await this.generateTubeProofWithBB(bbWorkingDirectory, input);
 
       // Read the proof as fields
+      // TODO(AD): this is the only remaining use of extractVkData.
       const tubeVK = await extractVkData(provingResult.vkPath!);
       const tubeProof = await this.readProofAsFields(provingResult.proofPath!, tubeVK, TUBE_PROOF_LENGTH);
 
@@ -631,12 +623,15 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   ): Promise<{ circuitOutput: CircuitOutputType; proof: RecursiveProof<PROOF_LENGTH> }> {
     // this probably is gonna need to call client ivc
     const operation = async (bbWorkingDirectory: string) => {
-      const {
-        provingResult,
-        vkData,
-        circuitOutput: output,
-      } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+      const { provingResult, circuitOutput: output } = await this.generateProofWithBB(
+        input,
+        circuitType,
+        convertInput,
+        convertOutput,
+        bbWorkingDirectory,
+      );
 
+      const vkData = this.getVerificationKeyDataForCircuit(circuitType);
       // Read the proof as fields
       const proof = await this.readProofAsFields(provingResult.proofPath!, vkData, proofLength);
 
@@ -674,7 +669,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param proof - The proof to be verified
    */
   public async verifyProof(circuitType: ServerProtocolArtifact, proof: Proof) {
-    const verificationKey = await this.getVerificationKeyDataForCircuit(circuitType);
+    const verificationKey = this.getVerificationKeyDataForCircuit(circuitType);
     return await this.verifyWithKey(getUltraHonkFlavorForCircuit(circuitType), verificationKey, proof);
   }
 
@@ -715,16 +710,6 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     await this.runInDirectory(operation);
   }
 
-  /**
-   * Returns the verification key for a circuit, will generate it if not cached internally
-   * @param circuitType - The type of circuit for which the verification key is required
-   * @returns The verification key
-   */
-  public async getVerificationKeyForCircuit(circuitType: ServerProtocolArtifact): Promise<VerificationKeyAsFields> {
-    const vkData = await this.getVerificationKeyDataForCircuit(circuitType);
-    return vkData.clone().keyAsFields;
-  }
-
   /**
    * Will check a recursive proof argument for validity of it's 'fields' format of proof and convert if required
    * @param proof - The input proof that may need converting
@@ -789,54 +774,16 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }
 
   /**
-   * Returns the verification key data for a circuit, will generate and cache it if not cached internally
+   * Returns the verification key data for a circuit.
    * @param circuitType - The type of circuit for which the verification key is required
    * @returns The verification key data
    */
-  private async getVerificationKeyDataForCircuit(circuitType: ServerProtocolArtifact): Promise<VerificationKeyData> {
-    const flavor = getUltraHonkFlavorForCircuit(circuitType);
-    let promise = this.verificationKeys.get(`${flavor}_${circuitType}`);
-    if (!promise) {
-      promise = generateKeyForNoirCircuit(
-        this.config.bbBinaryPath,
-        this.config.bbWorkingDirectory,
-        circuitType,
-        ServerCircuitArtifacts[circuitType],
-        SERVER_CIRCUIT_RECURSIVE,
-        flavor,
-        logger.debug,
-      ).then(result => {
-        if (result.status === BB_RESULT.FAILURE) {
-          throw new ProvingError(
-            `Failed to generate verification key for ${circuitType}, ${result.reason}`,
-            result,
-            result.retry,
-          );
-        }
-        return extractVkData(result.vkPath!);
-      });
-      this.verificationKeys.set(`${flavor}_${circuitType}`, promise);
-    }
-    const vk = await promise;
-    return vk.clone();
-  }
-
-  /**
-   * Ensures our verification key cache includes the key data located at the specified directory
-   * @param filePath - The directory containing the verification key data files
-   * @param circuitType - The type of circuit to which the verification key corresponds
-   */
-  private async updateVerificationKeyAfterProof(
-    filePath: string,
-    circuitType: ServerProtocolArtifact,
-  ): Promise<VerificationKeyData> {
-    const flavor = getUltraHonkFlavorForCircuit(circuitType);
-    let promise = this.verificationKeys.get(`${flavor}_${circuitType}`);
-    if (!promise) {
-      promise = extractVkData(filePath);
-      this.verificationKeys.set(`${flavor}_${circuitType}`, promise);
+  private getVerificationKeyDataForCircuit(circuitType: ServerProtocolArtifact): VerificationKeyData {
+    const vk = ServerCircuitVks[circuitType];
+    if (vk === undefined) {
+      throw new Error('Could not find VK for server artifact ' + circuitType);
     }
-    return promise;
+    return vk;
   }
 
   private async readProofAsFields<PROOF_LENGTH extends number>(

package/src/test/test_avm.ts

@@ -6,7 +6,6 @@ import {
   Gas,
   GlobalVariables,
   L2ToL1Message,
-  LogHash,
   MAX_ENQUEUED_CALLS_PER_CALL,
   MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
   MAX_L2_TO_L1_MSGS_PER_CALL,
@@ -17,11 +16,12 @@ import {
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_CALL,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
-  MAX_UNENCRYPTED_LOGS_PER_CALL,
+  MAX_PUBLIC_LOGS_PER_CALL,
   NoteHash,
   Nullifier,
   PublicCircuitPublicInputs,
   PublicInnerCallRequest,
+  PublicLog,
   ReadRequest,
   RevertCode,
   TreeLeafReadRequest,
@@ -73,7 +73,7 @@ export function getPublicInputs(result: PublicFunctionCallResult): PublicCircuit
       MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
     ),
     publicCallRequests: padArrayEnd([], PublicInnerCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_CALL),
-    unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
+    publicLogs: padArrayEnd(result.publicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_CALL),
     historicalHeader: BlockHeader.empty(),
     globalVariables: GlobalVariables.empty(),
     startGasLeft: Gas.from(result.startGasLeft),