@aztec/stdlib 3.0.0-nightly.20251113 → 3.0.0-nightly.20251115

package/src/tests/mocks.ts

@@ -1,10 +1,21 @@
-import { MAX_ENQUEUED_CALLS_PER_TX, MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+import {
+  FIXED_DA_GAS,
+  FIXED_L2_GAS,
+  MAX_ENQUEUED_CALLS_PER_TX,
+  MAX_INCLUDE_BY_TIMESTAMP_DURATION,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { times } from '@aztec/foundation/collection';
+import { padArrayEnd, times } from '@aztec/foundation/collection';
 import { Secp256k1Signer, randomBytes } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 
 import type { ContractArtifact } from '../abi/abi.js';
+import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
+import { PublicDataWrite } from '../avm/public_data_write.js';
+import { RevertCode } from '../avm/revert_code.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { CommitteeAttestation, L1PublishedData, L2BlockHeader } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
@@ -14,16 +25,21 @@ import { computeContractAddressFromInstance } from '../contract/contract_address
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
 import { SerializableContractInstance } from '../contract/contract_instance.js';
 import type { ContractInstanceWithAddress } from '../contract/index.js';
+import { computeEffectiveGasFees } from '../fees/transaction_fee.js';
 import { Gas } from '../gas/gas.js';
 import { GasFees } from '../gas/gas_fees.js';
 import { GasSettings } from '../gas/gas_settings.js';
+import type { GasUsed } from '../gas/gas_used.js';
+import type { MerkleTreeReadOperations } from '../interfaces/merkle_tree_operations.js';
 import { Nullifier } from '../kernel/nullifier.js';
 import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
 import {
   PartialPrivateTailPublicInputsForPublic,
   PrivateKernelTailCircuitPublicInputs,
 } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { PrivateToAvmAccumulatedData } from '../kernel/private_to_avm_accumulated_data.js';
 import { PrivateToPublicAccumulatedDataBuilder } from '../kernel/private_to_public_accumulated_data_builder.js';
+import { PublicCallRequestArrayLengths } from '../kernel/public_call_request.js';
 import { Note } from '../note/note.js';
 import { UniqueNote } from '../note/unique_note.js';
 import { BlockAttestation } from '../p2p/block_attestation.js';
@@ -31,12 +47,38 @@ import { BlockProposal } from '../p2p/block_proposal.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
 import { ChonkProof } from '../proofs/chonk_proof.js';
-import { HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, StateReference, Tx } from '../tx/index.js';
+import { ProvingRequestType } from '../proofs/proving_request_type.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import {
+  BlockHeader,
+  GlobalVariables,
+  HashedValues,
+  PrivateCallExecutionResult,
+  PrivateExecutionResult,
+  ProtocolContracts,
+  StateReference,
+  Tx,
+  TxConstantData,
+  makeProcessedTxFromPrivateOnlyTx,
+  makeProcessedTxFromTxWithPublicCalls,
+} from '../tx/index.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from '../tx/public_simulation_output.js';
 import { TxSimulationResult } from '../tx/simulated_tx.js';
 import { TxEffect } from '../tx/tx_effect.js';
 import { TxHash } from '../tx/tx_hash.js';
-import { makeGas, makeGlobalVariables, makeL2BlockHeader, makePublicCallRequest } from './factories.js';
+import {
+  makeAvmCircuitInputs,
+  makeAztecAddress,
+  makeGas,
+  makeGlobalVariables,
+  makeHeader,
+  makeL2BlockHeader,
+  makePrivateToPublicAccumulatedData,
+  makePrivateToRollupAccumulatedData,
+  makeProtocolContracts,
+  makePublicCallRequest,
+  makePublicDataWrite,
+} from './factories.js';
 
 export const randomTxHash = (): TxHash => TxHash.random();
 
@@ -159,6 +201,156 @@ export const mockTx = async (
 export const mockTxForRollup = (seed = 1, opts: Parameters<typeof mockTx>[1] = {}) =>
   mockTx(seed, { ...opts, numberOfNonRevertiblePublicCallRequests: 0, numberOfRevertiblePublicCallRequests: 0 });
 
+/** Mock a processed tx for testing purposes. */
+export async function mockProcessedTx({
+  seed = 1,
+  anchorBlockHeader,
+  db,
+  chainId = Fr.ZERO,
+  version = Fr.ZERO,
+  gasSettings = GasSettings.default({ maxFeesPerGas: new GasFees(10, 10) }),
+  vkTreeRoot = Fr.ZERO,
+  protocolContracts = makeProtocolContracts(seed + 0x100),
+  globalVariables = GlobalVariables.empty(),
+  newL1ToL2Snapshot = AppendOnlyTreeSnapshot.empty(),
+  feePayer,
+  feePaymentPublicDataWrite,
+  // The default gasUsed is the tx overhead.
+  gasUsed = Gas.from({ daGas: FIXED_DA_GAS, l2Gas: FIXED_L2_GAS }),
+  privateOnly = false,
+  ...mockTxOpts
+}: {
+  seed?: number;
+  anchorBlockHeader?: BlockHeader;
+  db?: MerkleTreeReadOperations;
+  gasSettings?: GasSettings;
+  globalVariables?: GlobalVariables;
+  newL1ToL2Snapshot?: AppendOnlyTreeSnapshot;
+  protocolContracts?: ProtocolContracts;
+  feePaymentPublicDataWrite?: PublicDataWrite;
+  privateOnly?: boolean;
+} & Parameters<typeof mockTx>[1] = {}) {
+  seed *= 0x1000; // Avoid clashing with the previous mock values if seed only increases by 1.
+  anchorBlockHeader ??= db?.getInitialHeader() ?? makeHeader(seed);
+  feePayer ??= makeAztecAddress(seed + 0x100);
+  feePaymentPublicDataWrite ??= makePublicDataWrite(seed + 0x200);
+
+  const txConstantData = TxConstantData.empty();
+  txConstantData.anchorBlockHeader = anchorBlockHeader;
+  txConstantData.txContext.chainId = chainId;
+  txConstantData.txContext.version = version;
+  txConstantData.txContext.gasSettings = gasSettings;
+  txConstantData.vkTreeRoot = vkTreeRoot;
+  txConstantData.protocolContractsHash = await protocolContracts.hash();
+
+  const tx = !privateOnly
+    ? await mockTx(seed, { feePayer, gasUsed, ...mockTxOpts })
+    : await mockTx(seed, {
+        numberOfNonRevertiblePublicCallRequests: 0,
+        numberOfRevertiblePublicCallRequests: 0,
+        feePayer,
+        gasUsed,
+        ...mockTxOpts,
+      });
+  tx.data.constants = txConstantData;
+
+  const transactionFee = tx.data.gasUsed.computeFee(globalVariables.gasFees);
+
+  if (privateOnly) {
+    const data = makePrivateToRollupAccumulatedData(seed + 0x1000, { numContractClassLogs: 0 });
+
+    tx.data.forRollup!.end = data;
+
+    await tx.recomputeHash();
+    return makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, globalVariables);
+  } else {
+    const dataFromPrivate = tx.data.forPublic!;
+
+    const nonRevertibleData = dataFromPrivate.nonRevertibleAccumulatedData;
+
+    // Create revertible data.
+    const revertibleData = makePrivateToPublicAccumulatedData(seed + 0x1000, { numContractClassLogs: 0 });
+    revertibleData.nullifiers[MAX_NULLIFIERS_PER_TX - 1] = Fr.ZERO; // Leave one space for the tx hash nullifier in nonRevertibleAccumulatedData.
+    dataFromPrivate.revertibleAccumulatedData = revertibleData;
+
+    // Create avm output.
+    const avmOutput = AvmCircuitPublicInputs.empty();
+    // Assign data from hints.
+    avmOutput.protocolContracts = protocolContracts;
+    avmOutput.startTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
+    avmOutput.endTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
+    avmOutput.effectiveGasFees = computeEffectiveGasFees(globalVariables.gasFees, gasSettings);
+    // Assign data from private.
+    avmOutput.globalVariables = globalVariables;
+    avmOutput.startGasUsed = tx.data.gasUsed;
+    avmOutput.gasSettings = gasSettings;
+    avmOutput.feePayer = feePayer;
+    avmOutput.publicCallRequestArrayLengths = new PublicCallRequestArrayLengths(
+      tx.data.numberOfNonRevertiblePublicCallRequests(),
+      tx.data.numberOfRevertiblePublicCallRequests(),
+      tx.data.hasTeardownPublicCallRequest(),
+    );
+    avmOutput.publicSetupCallRequests = dataFromPrivate.nonRevertibleAccumulatedData.publicCallRequests;
+    avmOutput.publicAppLogicCallRequests = dataFromPrivate.revertibleAccumulatedData.publicCallRequests;
+    avmOutput.publicTeardownCallRequest = dataFromPrivate.publicTeardownCallRequest;
+    avmOutput.previousNonRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(
+      dataFromPrivate.nonRevertibleAccumulatedData.noteHashes,
+      dataFromPrivate.nonRevertibleAccumulatedData.nullifiers,
+      dataFromPrivate.nonRevertibleAccumulatedData.l2ToL1Msgs,
+    );
+    avmOutput.previousNonRevertibleAccumulatedDataArrayLengths =
+      avmOutput.previousNonRevertibleAccumulatedData.getArrayLengths();
+    avmOutput.previousRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(
+      dataFromPrivate.revertibleAccumulatedData.noteHashes,
+      dataFromPrivate.revertibleAccumulatedData.nullifiers,
+      dataFromPrivate.revertibleAccumulatedData.l2ToL1Msgs,
+    );
+    avmOutput.previousRevertibleAccumulatedDataArrayLengths =
+      avmOutput.previousRevertibleAccumulatedData.getArrayLengths();
+    // Assign final data emitted from avm.
+    avmOutput.accumulatedData.noteHashes = revertibleData.noteHashes;
+    avmOutput.accumulatedData.nullifiers = padArrayEnd(
+      nonRevertibleData.nullifiers.concat(revertibleData.nullifiers).filter(n => !n.isEmpty()),
+      Fr.ZERO,
+      MAX_NULLIFIERS_PER_TX,
+    );
+    avmOutput.accumulatedData.l2ToL1Msgs = revertibleData.l2ToL1Msgs;
+    avmOutput.accumulatedData.publicDataWrites = makeTuple(
+      MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+      i => new PublicDataWrite(new Fr(i), new Fr(i + 10)),
+      seed + 0x2000,
+    );
+    avmOutput.accumulatedData.publicDataWrites[0] = feePaymentPublicDataWrite;
+    avmOutput.accumulatedDataArrayLengths = avmOutput.accumulatedData.getArrayLengths();
+    avmOutput.gasSettings = gasSettings;
+    // Note: The fee is computed from the tx's gas used, which only includes the gas used in private. But this shouldn't
+    // be a problem for the tests.
+    avmOutput.transactionFee = transactionFee;
+
+    const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, { publicInputs: avmOutput });
+    avmCircuitInputs.hints.startingTreeRoots.l1ToL2MessageTree = newL1ToL2Snapshot;
+
+    const gasUsed = {
+      totalGas: Gas.empty(),
+      teardownGas: Gas.empty(),
+      publicGas: Gas.empty(),
+      billedGas: Gas.empty(),
+    } satisfies GasUsed;
+
+    await tx.recomputeHash();
+    return makeProcessedTxFromTxWithPublicCalls(
+      tx,
+      {
+        type: ProvingRequestType.PUBLIC_VM,
+        inputs: avmCircuitInputs,
+      },
+      gasUsed,
+      RevertCode.OK,
+      undefined /* revertReason */,
+    );
+  }
+}
+
 const emptyPrivateCallExecutionResult = () =>
   new PrivateCallExecutionResult(
     Buffer.from(''),

package/src/tx/partial_state_reference.ts

@@ -2,6 +2,7 @@ import { PARTIAL_STATE_REFERENCE_LENGTH } from '@aztec/constants';
 import type { ViemPartialStateReference } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
@@ -37,6 +38,14 @@ export class PartialStateReference {
     return this.noteHashTree.getSize() + this.nullifierTree.getSize() + this.publicDataTree.getSize();
   }
 
+  static getFields(fields: FieldsOf<PartialStateReference>) {
+    return [fields.noteHashTree, fields.nullifierTree, fields.publicDataTree] as const;
+  }
+
+  static from(fields: FieldsOf<PartialStateReference>) {
+    return new PartialStateReference(...PartialStateReference.getFields(fields));
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader): PartialStateReference {
     const reader = BufferReader.asReader(buffer);
     return new PartialStateReference(

package/src/tx/state_reference.ts

@@ -7,6 +7,7 @@ import {
 import type { ViemStateReference } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -38,6 +39,14 @@ export class StateReference {
     return this.l1ToL2MessageTree.getSize() + this.partial.getSize();
   }
 
+  static getFields(fields: FieldsOf<StateReference>) {
+    return [fields.l1ToL2MessageTree, fields.partial] as const;
+  }
+
+  static from(fields: FieldsOf<StateReference>) {
+    return new StateReference(...StateReference.getFields(fields));
+  }
+
   toBuffer() {
     // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer(this.l1ToL2MessageTree, this.partial);

package/src/tx/tx_effect.ts

@@ -1,4 +1,10 @@
-import { decodeTxStartMarker, encodeTxStartMarker, isValidTxStartMarker } from '@aztec/blob-lib/encoding';
+import {
+  type TxBlobData,
+  type TxStartMarker,
+  decodeTxBlobData,
+  encodeTxBlobData,
+  getNumTxBlobFields,
+} from '@aztec/blob-lib/encoding';
 import {
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
@@ -10,14 +16,8 @@ import {
 import { type FieldsOf, makeTuple, makeTupleAsync } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
-import {
-  BufferReader,
-  FieldReader,
-  serializeArrayOfBufferableToVector,
-  serializeToBuffer,
-} from '@aztec/foundation/serialize';
+import { BufferReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import { computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -27,6 +27,7 @@ import { RevertCode } from '../avm/revert_code.js';
 import { ContractClassLog } from '../logs/contract_class_log.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
+import { computeTxOutHash } from '../messaging/out_hash.js';
 import { TxHash } from './tx_hash.js';
 
 export class TxEffect {
@@ -160,11 +161,6 @@ export class TxEffect {
     );
   }
 
-  /** Returns the size of this tx effect in bytes as serialized onto DA. */
-  getDASize() {
-    return this.toBlobFields().length * Fr.SIZE_IN_BYTES;
-  }
-
   /**
    * Deserializes the TxEffect object from a Buffer.
    * @param buffer - Buffer or BufferReader object to deserialize.
@@ -191,13 +187,8 @@ export class TxEffect {
    * Computes txOutHash of this tx effect.
    * @dev Follows new_sha in unbalanced_merkle_tree.nr
    */
-  txOutHash(): Buffer {
-    const { l2ToL1Msgs } = this;
-    if (l2ToL1Msgs.length == 0) {
-      return Buffer.alloc(32);
-    }
-
-    return computeUnbalancedMerkleTreeRoot(l2ToL1Msgs.map(msg => msg.toBuffer()));
+  txOutHash(): Fr {
+    return computeTxOutHash(this.l2ToL1Msgs);
   }
 
   static async random(
@@ -242,71 +233,74 @@ export class TxEffect {
     return bufferToHex(this.toBuffer());
   }
 
-  /**
-   * Returns a flat packed array of fields of all tx effects, to be appended to blobs.
-   * Must match the implementation in noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr
-   */
-  toBlobFields(): Fr[] {
-    const flattened: Fr[] = [];
+  getNumBlobFields(): number {
+    return this.getTxStartMarker().numBlobFields;
+  }
 
-    // We reassign the first field at the end when we know the length of all effects to create the tx start marker.
-    flattened.push(Fr.ZERO);
+  toBlobFields(): Fr[] {
+    return encodeTxBlobData(this.toTxBlobData());
+  }
 
-    flattened.push(this.txHash.hash);
-    flattened.push(this.transactionFee);
-    flattened.push(...this.noteHashes);
-    flattened.push(...this.nullifiers);
-    flattened.push(...this.l2ToL1Msgs);
-    flattened.push(...this.publicDataWrites.flatMap(w => w.toBlobFields()));
-    flattened.push(...this.privateLogs.flatMap(l => l.toBlobFields()));
-    const flattenedPublicLogs = FlatPublicLogs.fromLogs(this.publicLogs);
-    flattened.push(...flattenedPublicLogs.toBlobFields());
-    flattened.push(...this.contractClassLogs.flatMap(l => l.toBlobFields()));
+  static fromBlobFields(fields: Fr[]) {
+    return TxEffect.fromTxBlobData(decodeTxBlobData(fields));
+  }
 
-    flattened[0] = encodeTxStartMarker({
+  getTxStartMarker(): TxStartMarker {
+    const flatPublicLogs = FlatPublicLogs.fromLogs(this.publicLogs);
+    const partialTxStartMarker = {
       revertCode: this.revertCode.getCode(),
-      numBlobFields: flattened.length,
       numNoteHashes: this.noteHashes.length,
       numNullifiers: this.nullifiers.length,
       numL2ToL1Msgs: this.l2ToL1Msgs.length,
       numPublicDataWrites: this.publicDataWrites.length,
       numPrivateLogs: this.privateLogs.length,
-      publicLogsLength: flattenedPublicLogs.length,
+      privateLogsLength: this.privateLogs.reduce((acc, log) => acc + log.emittedLength, 0),
+      publicLogsLength: flatPublicLogs.length,
       contractClassLogLength: this.contractClassLogs[0]?.emittedLength ?? 0,
-    });
+    };
+    const numBlobFields = getNumTxBlobFields(partialTxStartMarker);
+    return {
+      ...partialTxStartMarker,
+      numBlobFields,
+    };
+  }
 
-    return flattened;
+  /**
+   * Returns a flat packed array of fields of all tx effects, to be appended to blobs.
+   * Must match the implementation in noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr
+   */
+  toTxBlobData(): TxBlobData {
+    return {
+      txStartMarker: this.getTxStartMarker(),
+      txHash: this.txHash.hash,
+      transactionFee: this.transactionFee,
+      noteHashes: this.noteHashes,
+      nullifiers: this.nullifiers,
+      l2ToL1Msgs: this.l2ToL1Msgs,
+      publicDataWrites: this.publicDataWrites.map(w => w.toBlobFields()),
+      privateLogs: this.privateLogs.map(l => l.toBlobFields()),
+      publicLogs: FlatPublicLogs.fromLogs(this.publicLogs).toBlobFields(),
+      contractClassLog: this.contractClassLogs.map(l => l.toBlobFields()).flat(),
+    };
   }
 
   /**
    * Decodes a flat packed array of fields to TxEffect.
    */
-  static fromBlobFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    const totalFields = reader.remainingFields();
-    if (!totalFields) {
-      throw new Error('Cannot process empty blob fields.');
-    }
-
-    const txStartMarker = decodeTxStartMarker(reader.readField());
-    if (!isValidTxStartMarker(txStartMarker)) {
-      throw new Error('Invalid fields given to TxEffect.fromBlobFields(): invalid TxStartMarker');
-    }
-
-    const revertCode = RevertCode.fromField(new Fr(txStartMarker.revertCode));
-    const txHash = new TxHash(reader.readField());
-    const transactionFee = reader.readField();
-    const noteHashes = reader.readFieldArray(txStartMarker.numNoteHashes);
-    const nullifiers = reader.readFieldArray(txStartMarker.numNullifiers);
-    const l2ToL1Msgs = reader.readFieldArray(txStartMarker.numL2ToL1Msgs);
-    const publicDataWrites = Array.from({ length: txStartMarker.numPublicDataWrites }, () =>
-      PublicDataWrite.fromBlobFields(reader),
-    );
-    const privateLogs = Array.from({ length: txStartMarker.numPrivateLogs }, () => PrivateLog.fromBlobFields(reader));
-    const publicLogs = FlatPublicLogs.fromBlobFields(txStartMarker.publicLogsLength, reader).toLogs();
+  static fromTxBlobData(txBlobData: TxBlobData) {
+    const txStartMarker = txBlobData.txStartMarker;
+    const revertCode = RevertCode.fromNumber(txStartMarker.revertCode);
+    const txHash = new TxHash(txBlobData.txHash);
+    const transactionFee = txBlobData.transactionFee;
+    const noteHashes = txBlobData.noteHashes;
+    const nullifiers = txBlobData.nullifiers;
+    const l2ToL1Msgs = txBlobData.l2ToL1Msgs;
+    const publicDataWrites = txBlobData.publicDataWrites.map(w => PublicDataWrite.fromBlobFields(w));
+    const privateLogs = txBlobData.privateLogs.map(l => PrivateLog.fromBlobFields(l.length, l));
+    const publicLogs = FlatPublicLogs.fromBlobFields(txStartMarker.publicLogsLength, txBlobData.publicLogs).toLogs();
     const contractClassLogs =
       txStartMarker.contractClassLogLength > 0
-        ? [ContractClassLog.fromBlobFields(txStartMarker.contractClassLogLength, reader)]
+        ? [ContractClassLog.fromBlobFields(txStartMarker.contractClassLogLength, txBlobData.contractClassLog)]
         : [];
 
     return TxEffect.from({

package/dest/checkpoint/checkpoint_body.d.ts

@@ -1,4 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { TxEffect } from '../tx/tx_effect.js';
-export declare function getCheckpointBlobFields(txEffectsInBlocks: TxEffect[][]): Fr[];
-//# sourceMappingURL=checkpoint_body.d.ts.map

package/dest/checkpoint/checkpoint_body.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkpoint_body.d.ts","sourceRoot":"","sources":["../../src/checkpoint/checkpoint_body.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,wBAAgB,uBAAuB,CAAC,iBAAiB,EAAE,QAAQ,EAAE,EAAE,QAItE"}

package/dest/checkpoint/checkpoint_body.js

@@ -1,9 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { getBlockBlobFields } from '../block/body.js';
-export function getCheckpointBlobFields(txEffectsInBlocks) {
-    const blockBlobFields = txEffectsInBlocks.map((blockTxEffects)=>getBlockBlobFields(blockTxEffects)).flat();
-    const totalNumBlobFields = blockBlobFields.length + 1; // +1 for the prefix indicating the number of total blob fields in a checkpoint.
-    return [
-        new Fr(totalNumBlobFields)
-    ].concat(blockBlobFields);
-}

package/src/checkpoint/checkpoint_body.ts

@@ -1,10 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-
-import { getBlockBlobFields } from '../block/body.js';
-import type { TxEffect } from '../tx/tx_effect.js';
-
-export function getCheckpointBlobFields(txEffectsInBlocks: TxEffect[][]) {
-  const blockBlobFields = txEffectsInBlocks.map(blockTxEffects => getBlockBlobFields(blockTxEffects)).flat();
-  const totalNumBlobFields = blockBlobFields.length + 1; // +1 for the prefix indicating the number of total blob fields in a checkpoint.
-  return [new Fr(totalNumBlobFields)].concat(blockBlobFields);
-}