@aztec/stdlib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/block/validate_block_result.ts

@@ -0,0 +1,124 @@
+import { EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { BlockInfoSchema, type L2BlockInfo, deserializeBlockInfo, serializeBlockInfo } from './l2_block_info.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+
+/** Subtype for invalid block validation results */
+export type ValidateBlockNegativeResult =
+  | {
+      valid: false;
+      /** Identifiers from the invalid block */
+      block: L2BlockInfo;
+      /** Committee members at the epoch this block was proposed */
+      committee: EthAddress[];
+      /** Epoch in which this block was proposed */
+      epoch: EpochNumber;
+      /** Proposer selection seed for the epoch */
+      seed: bigint;
+      /** List of committee members who signed this block proposal */
+      attestors: EthAddress[];
+      /** Committee attestations for this block as they were posted to L1 */
+      attestations: CommitteeAttestation[];
+      /** Reason for the block being invalid: not enough attestations were posted */
+      reason: 'insufficient-attestations';
+    }
+  | {
+      valid: false;
+      /** Identifiers from the invalid block */
+      block: L2BlockInfo;
+      /** Committee members at the epoch this block was proposed */
+      committee: EthAddress[];
+      /** Epoch in which this block was proposed */
+      epoch: EpochNumber;
+      /** Proposer selection seed for the epoch */
+      seed: bigint;
+      /** List of committee members who signed this block proposal */
+      attestors: EthAddress[];
+      /** Committee attestations for this block as they were posted to L1 */
+      attestations: CommitteeAttestation[];
+      /** Reason for the block being invalid: an invalid attestation was posted */
+      reason: 'invalid-attestation';
+      /** Index in the attestations array of the invalid attestation posted */
+      invalidIndex: number;
+    };
+
+// TODO: Rename to ValidateAttestationsResult
+/** Result type for validating a block attestations */
+export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
+
+export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
+  z.object({ valid: z.literal(true) }),
+  z.object({
+    valid: z.literal(false),
+    block: BlockInfoSchema,
+    committee: z.array(schemas.EthAddress),
+    epoch: EpochNumberSchema,
+    seed: schemas.BigInt,
+    attestors: z.array(schemas.EthAddress),
+    attestations: z.array(CommitteeAttestation.schema),
+    reason: z.literal('insufficient-attestations'),
+  }),
+  z.object({
+    valid: z.literal(false),
+    block: BlockInfoSchema,
+    committee: z.array(schemas.EthAddress),
+    epoch: EpochNumberSchema,
+    seed: schemas.BigInt,
+    attestors: z.array(schemas.EthAddress),
+    attestations: z.array(CommitteeAttestation.schema),
+    reason: z.literal('invalid-attestation'),
+    invalidIndex: z.number(),
+  }),
+]);
+
+export function serializeValidateBlockResult(result: ValidateBlockResult): Buffer {
+  if (result.valid) {
+    return serializeToBuffer(true);
+  }
+
+  const l2Block = serializeBlockInfo(result.block);
+  return serializeToBuffer(
+    result.valid,
+    result.reason,
+    l2Block.length,
+    l2Block,
+    result.committee.length,
+    result.committee,
+    result.epoch,
+    result.seed ?? 0n,
+    result.attestors.length,
+    result.attestors,
+    result.attestations.length,
+    result.attestations,
+    result.reason === 'invalid-attestation' ? result.invalidIndex : 0,
+  );
+}
+
+export function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferReader): ValidateBlockResult {
+  const reader = BufferReader.asReader(bufferOrReader);
+  const valid = reader.readBoolean();
+  if (valid) {
+    return { valid };
+  }
+  const reason = reader.readString() as 'insufficient-attestations' | 'invalid-attestation';
+  const block = deserializeBlockInfo(reader.readBuffer());
+  const committee = reader.readVector(EthAddress);
+  const epoch = EpochNumber(reader.readNumber());
+  const seed = reader.readBigInt();
+  const attestors = reader.readVector(EthAddress);
+  const attestations = reader.readVector(CommitteeAttestation);
+  const invalidIndex = reader.readNumber();
+  if (reason === 'insufficient-attestations') {
+    return { valid, reason, block, committee, epoch, seed, attestors, attestations: attestations };
+  } else if (reason === 'invalid-attestation') {
+    return { valid, reason, block, committee, epoch, seed, attestors, invalidIndex, attestations: attestations };
+  } else {
+    const _: never = reason;
+    throw new Error(`Unknown reason: ${reason}`);
+  }
+}

package/src/checkpoint/checkpoint.ts

@@ -0,0 +1,135 @@
+import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
+import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { sum } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { L2BlockNew } from '../block/l2_block_new.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import type { CheckpointInfo } from './checkpoint_info.js';
+
+export class Checkpoint {
+  constructor(
+    /** Snapshot of archive tree after the checkpoint is added. */
+    public archive: AppendOnlyTreeSnapshot,
+    /** Header of the checkpoint. */
+    public header: CheckpointHeader,
+    /** L2 blocks in the checkpoint. */
+    public blocks: L2BlockNew[],
+    /** Number of the checkpoint. */
+    public number: CheckpointNumber,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        archive: AppendOnlyTreeSnapshot.schema,
+        header: CheckpointHeader.schema,
+        blocks: z.array(L2BlockNew.schema),
+        number: CheckpointNumberSchema,
+      })
+      .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
+  }
+
+  static from(fields: FieldsOf<Checkpoint>) {
+    return new Checkpoint(...Checkpoint.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<Checkpoint>) {
+    return [fields.archive, fields.header, fields.blocks, fields.number] as const;
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buf);
+    return new Checkpoint(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(CheckpointHeader),
+      reader.readVector(L2BlockNew),
+      CheckpointNumber(reader.readNumber()),
+    );
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.archive, this.header, this.blocks.length, this.blocks, this.number);
+  }
+
+  public toBlobFields(): Fr[] {
+    const blocks = this.blocks.map(block => block.toBlockBlobData());
+    return encodeCheckpointBlobDataFromBlocks(blocks);
+  }
+
+  public hash(): Fr {
+    return this.header.hash();
+  }
+
+  public getState() {
+    return this.blocks.at(-1)!.header.state;
+  }
+
+  public toCheckpointInfo(): CheckpointInfo {
+    return {
+      archive: this.archive.root,
+      slotNumber: this.header.slotNumber,
+      checkpointNumber: this.number,
+      timestamp: this.header.timestamp,
+    };
+  }
+
+  /** Returns stats used for logging */
+  public getStats() {
+    const txEffects = this.blocks.flatMap(block => block.body.txEffects);
+
+    const logsStats = {
+      privateLogCount: sum(txEffects.map(tx => tx.privateLogs.length)),
+      publicLogCount: sum(txEffects.map(tx => tx.publicLogs.length)),
+      contractClassLogCount: sum(txEffects.map(tx => tx.contractClassLogs.length)),
+      contractClassLogSize: sum(txEffects.map(tx => sum(tx.contractClassLogs.map(log => log.emittedLength)))),
+    };
+
+    return {
+      txCount: txEffects.length,
+      blockCount: this.blocks.length,
+      slotNumber: this.header.slotNumber,
+      checkpointNumber: this.number,
+      timestamp: this.header.timestamp,
+      ...logsStats,
+    };
+  }
+
+  static async random(
+    checkpointNumber = CheckpointNumber(1),
+    {
+      numBlocks = 1,
+      startBlockNumber = 1,
+      previousArchive,
+      ...options
+    }: {
+      numBlocks?: number;
+      startBlockNumber?: number;
+      previousArchive?: AppendOnlyTreeSnapshot;
+    } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
+      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+  ) {
+    const header = CheckpointHeader.random(options);
+
+    // Create blocks sequentially to chain archive roots properly.
+    // Each block's header.lastArchive must equal the previous block's archive.
+    const blocks: L2BlockNew[] = [];
+    let lastArchive = previousArchive;
+    for (let i = 0; i < numBlocks; i++) {
+      const block = await L2BlockNew.random(BlockNumber(startBlockNumber + i), {
+        indexWithinCheckpoint: i,
+        ...options,
+        ...(lastArchive ? { lastArchive } : {}),
+      });
+      lastArchive = block.archive;
+      blocks.push(block);
+    }
+
+    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber);
+  }
+}

package/src/checkpoint/checkpoint_info.ts

@@ -0,0 +1,9 @@
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr, SlotNumber } from '@aztec/foundation/schemas';
+
+export type CheckpointInfo = {
+  archive: Fr;
+  slotNumber: SlotNumber;
+  checkpointNumber: CheckpointNumber;
+  timestamp: bigint;
+};

package/src/checkpoint/index.ts

@@ -0,0 +1,2 @@
+export * from './checkpoint.js';
+export * from './published_checkpoint.js';

package/src/checkpoint/published_checkpoint.ts

@@ -0,0 +1,105 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto/random';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { Checkpoint } from './checkpoint.js';
+
+export class L1PublishedData {
+  constructor(
+    public blockNumber: bigint,
+    public timestamp: bigint,
+    public blockHash: string,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        blockNumber: schemas.BigInt,
+        timestamp: schemas.BigInt,
+        blockHash: z.string(),
+      })
+      .transform(obj => L1PublishedData.fromFields(obj));
+  }
+
+  static random() {
+    return new L1PublishedData(
+      randomBigInt(1000n) + 1n,
+      BigInt(Math.floor(Date.now() / 1000)),
+      Buffer32.random().toString(),
+    );
+  }
+
+  static fromFields(fields: FieldsOf<L1PublishedData>) {
+    return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): L1PublishedData {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    return new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash);
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.blockNumber, this.blockHash, this.timestamp);
+  }
+}
+
+export class PublishedCheckpoint {
+  constructor(
+    public checkpoint: Checkpoint,
+    public l1: L1PublishedData,
+    // The attestations for the last block in the checkpoint.
+    public attestations: CommitteeAttestation[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        checkpoint: Checkpoint.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => PublishedCheckpoint.from(obj));
+  }
+
+  static getFields(fields: FieldsOf<PublishedCheckpoint>) {
+    return [fields.checkpoint, fields.l1, fields.attestations] as const;
+  }
+
+  static from(fields: FieldsOf<PublishedCheckpoint>) {
+    return new PublishedCheckpoint(...PublishedCheckpoint.getFields(fields));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedCheckpoint {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const checkpoint = reader.readObject(Checkpoint);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    return new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.checkpoint,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}

package/src/config/node-rpc-config.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
 
 export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
@@ -6,6 +7,12 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
     description: 'Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`.',
     ...numberConfigHelper(10e9),
   },
+  rpcSimulatePublicMaxDebugLogMemoryReads: {
+    env: 'RPC_SIMULATE_PUBLIC_MAX_DEBUG_LOG_MEMORY_READS',
+    description:
+      'Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. ',
+    ...numberConfigHelper(DEFAULT_MAX_DEBUG_LOG_MEMORY_READS),
+  },
   rpcMaxBatchSize: {
     env: 'RPC_MAX_BATCH_SIZE',
     description: 'Maximum allowed batch size for JSON RPC batch requests.',
@@ -21,6 +28,8 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
 export type NodeRPCConfig = {
   /** Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`. */
   rpcSimulatePublicMaxGasLimit: number;
+  /** Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. */
+  rpcSimulatePublicMaxDebugLogMemoryReads: number;
   /** Maximum allowed batch size for JSON RPC batch requests. */
   rpcMaxBatchSize: number;
   /** The maximum body size the RPC server will accept */

package/src/contract/artifact_hash.ts

@@ -1,5 +1,5 @@
-import { sha256 } from '@aztec/foundation/crypto';
-import { Fr, reduceFn } from '@aztec/foundation/fields';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
+import { Fr, reduceFn } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { numToUInt8 } from '@aztec/foundation/serialize';
 import { MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';

package/src/contract/complete_address.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex } from '@aztec/foundation/string';

package/src/contract/contract_address.ts

@@ -1,6 +1,6 @@
 import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { type FunctionAbi, FunctionSelector, encodeArguments } from '../abi/index.js';
 import type { AztecAddress } from '../aztec-address/index.js';
@@ -11,7 +11,7 @@ import type { ContractInstance } from './interfaces/contract_instance.js';
 // TODO(@spalladino): Review all generator indices in this file
 
 /**
- * Returns the deployment address for a given contract instance as defined on the [Protocol Specs](../../../../docs/docs/protocol-specs/addresses-and-keys/specification.md).
+ * Returns the deployment address for a given contract instance.
  * ```
  * salted_initialization_hash = pedersen([salt, initialization_hash, deployer], GENERATOR__SALTED_INITIALIZATION_HASH)
  * partial_address = pedersen([contract_class_id, salted_initialization_hash], GENERATOR__CONTRACT_PARTIAL_ADDRESS_V1)

package/src/contract/contract_class.ts

@@ -1,5 +1,5 @@
-import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto/keys';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
 import { hashVK } from '../hash/hash.js';

package/src/contract/contract_class_id.ts

@@ -1,6 +1,6 @@
 import { GeneratorIndex, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { strict as assert } from 'assert';
 
@@ -40,7 +40,7 @@ export async function computeContractClassIdWithPreimage(
       : await computePublicBytecodeCommitment(contractClass.packedBytecode);
   const id = await poseidon2HashWithSeparator(
     [artifactHash, privateFunctionsRoot, publicBytecodeCommitment],
-    GeneratorIndex.CONTRACT_LEAF, // TODO(@spalladino): Review all generator indices in this file
+    GeneratorIndex.CONTRACT_CLASS_ID,
   );
   return { id, artifactHash, privateFunctionsRoot, publicBytecodeCommitment };
 }

package/src/contract/contract_class_metadata.ts

@@ -0,0 +1,8 @@
+import type { ContractArtifact } from '../abi/abi.js';
+import type { ContractClassWithId } from './interfaces/contract_class.js';
+
+export interface ContractClassMetadata {
+  contractClass?: ContractClassWithId | undefined;
+  isContractClassPubliclyRegistered: boolean;
+  artifact?: ContractArtifact | undefined;
+}

package/src/contract/contract_deployment_data.ts

@@ -0,0 +1,125 @@
+import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
+import type { Tx } from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+/**
+ * Class containing contract class logs and private logs which are both
+ * relevant for contract registrations and deployments.
+ */
+export class ContractDeploymentData {
+  constructor(
+    public readonly contractClassLogs: ContractClassLog[],
+    public readonly privateLogs: PrivateLog[],
+  ) {}
+
+  public getContractClassLogs(): ContractClassLog[] {
+    return this.contractClassLogs;
+  }
+
+  public getPrivateLogs(): PrivateLog[] {
+    return this.privateLogs;
+  }
+
+  public static from(args: { contractClassLogs: ContractClassLog[]; privateLogs: PrivateLog[] }) {
+    return new ContractDeploymentData(args.contractClassLogs, args.privateLogs);
+  }
+
+  public static empty(): ContractDeploymentData {
+    return new ContractDeploymentData([], []);
+  }
+
+  public static get schema() {
+    return z
+      .object({
+        contractClassLogs: z.array(ContractClassLog.schema),
+        privateLogs: z.array(PrivateLog.schema),
+      })
+      .transform(ContractDeploymentData.from);
+  }
+
+  /**
+   * Creates a ContractDeploymentData from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ContractDeploymentData fields
+   * @returns A ContractDeploymentData instance
+   */
+  public static fromPlainObject(obj: any): ContractDeploymentData {
+    if (obj instanceof ContractDeploymentData) {
+      return obj;
+    }
+    return new ContractDeploymentData(
+      obj.contractClassLogs.map((log: any) => ContractClassLog.fromPlainObject(log)),
+      obj.privateLogs.map((log: any) => PrivateLog.fromPlainObject(log)),
+    );
+  }
+}
+
+/**
+ * Class containing both revertible and non-revertible registration/deployment data.
+ */
+export class AllContractDeploymentData {
+  constructor(
+    public readonly nonRevertibleContractDeploymentData: ContractDeploymentData,
+    public readonly revertibleContractDeploymentData: ContractDeploymentData,
+  ) {}
+
+  public getNonRevertibleContractDeploymentData(): ContractDeploymentData {
+    return this.nonRevertibleContractDeploymentData;
+  }
+
+  public getRevertibleContractDeploymentData(): ContractDeploymentData {
+    return this.revertibleContractDeploymentData;
+  }
+
+  /**
+   * Extracts all contract registration/deployment data from a tx separated by revertibility.
+   * This includes contract class logs and private logs.
+   *
+   * This method handles both private-only transactions and transactions with public calls,
+   * properly splitting logs between revertible and non-revertible categories.
+   * @param tx - The transaction to extract data from
+   * @returns The extracted deployment data separated by revertibility
+   */
+  static fromTx(tx: Tx): AllContractDeploymentData {
+    const hasPublicCalls = !!tx.data.forPublic;
+
+    // Extract contract class logs from the tx
+    const allClassLogs = tx.getContractClassLogs();
+    let nonRevertibleClassLogs: ContractClassLog[];
+    let revertibleClassLogs: ContractClassLog[];
+
+    if (hasPublicCalls) {
+      // Transactions with public calls can have both revertible and non-revertible contract class logs
+      // Split the logs up here based on revertibility
+      nonRevertibleClassLogs = tx.getSplitContractClassLogs(/*revertible=*/ false);
+      revertibleClassLogs = tx.getSplitContractClassLogs(/*revertible=*/ true);
+    } else {
+      // Private-only tx: all logs are non-revertible
+      nonRevertibleClassLogs = allClassLogs;
+      revertibleClassLogs = [];
+    }
+
+    // Extract contract instance logs from the transaction's private logs
+    let nonRevertibleInstanceLogs: PrivateLog[];
+    let revertibleInstanceLogs: PrivateLog[];
+
+    if (hasPublicCalls) {
+      // Transactions with public calls can have both revertible and non-revertible contract instance logs
+      // Split the logs up here based on revertibility
+      nonRevertibleInstanceLogs = tx.data.forPublic!.nonRevertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty());
+      revertibleInstanceLogs = tx.data.forPublic!.revertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty());
+    } else {
+      // Private-only tx: use logs from the `forRollup` member of the tx
+      // For private-only txs, all logs are non-revertible
+      nonRevertibleInstanceLogs = tx.data.forRollup!.end.privateLogs.filter(l => !l.isEmpty());
+      revertibleInstanceLogs = [];
+    }
+
+    return new AllContractDeploymentData(
+      new ContractDeploymentData(nonRevertibleClassLogs, nonRevertibleInstanceLogs),
+      new ContractDeploymentData(revertibleClassLogs, revertibleInstanceLogs),
+    );
+  }
+}

package/src/contract/contract_instance.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -22,6 +22,15 @@ import type { ContractInstance, ContractInstanceWithAddress } from './interfaces
 
 const VERSION = 1 as const;
 
+export type ContractInstantiationData = {
+  constructorArtifact?: FunctionAbi | string;
+  constructorArgs?: any[];
+  skipArgsDecoding?: boolean;
+  salt: Fr;
+  publicKeys?: PublicKeys;
+  deployer?: AztecAddress;
+};
+
 export class SerializableContractInstance {
   public readonly version = VERSION;
   public readonly salt: Fr;
@@ -107,17 +116,9 @@ export class SerializableContractInstance {
  */
 export async function getContractInstanceFromInstantiationParams(
   artifact: ContractArtifact,
-  opts: {
-    constructorArtifact?: FunctionAbi | string;
-    constructorArgs?: any[];
-    skipArgsDecoding?: boolean;
-    salt?: Fr;
-    publicKeys?: PublicKeys;
-    deployer?: AztecAddress;
-  },
+  opts: ContractInstantiationData,
 ): Promise<ContractInstanceWithAddress> {
   const args = opts.constructorArgs ?? [];
-  const salt = opts.salt ?? Fr.random();
   const constructorArtifact = getConstructorArtifact(artifact, opts.constructorArtifact);
   const deployer = opts.deployer ?? AztecAddress.ZERO;
   const contractClass = await getContractClassFromArtifact(artifact);
@@ -135,7 +136,7 @@ export async function getContractInstanceFromInstantiationParams(
     originalContractClassId: contractClass.id,
     initializationHash,
     publicKeys,
-    salt,
+    salt: opts.salt,
     deployer,
     version: 1,
   };

package/src/contract/contract_instance_update.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/contract/contract_metadata.ts

@@ -0,0 +1,7 @@
+import type { ContractInstanceWithAddress } from './interfaces/contract_instance.js';
+
+export interface ContractMetadata {
+  contractInstance?: ContractInstanceWithAddress | undefined;
+  isContractInitialized: boolean;
+  isContractPublished: boolean;
+}

package/src/contract/deployment_info.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { CompleteAddress } from './complete_address.js';