@aztec/stdlib 3.0.3 → 4.0.0-devnet.1-patch.1

package/src/kernel/private_circuit_public_inputs.ts

@@ -57,6 +57,18 @@ export class PrivateCircuitPublicInputs {
      * Pedersen hash of the return values of the corresponding function call.
      */
     public returnsHash: Fr,
+    /**
+     * Header of a block whose state is used during private execution (not the block the transaction is included in).
+     */
+    public anchorBlockHeader: BlockHeader,
+    /**
+     * Transaction context.
+     *
+     * Note: The chainId and version in the txContext are not redundant to the values in self.anchor_block_header.global_variables because
+     * they can be different in case of a protocol upgrade. In such a situation we could be using header from a block
+     * before the upgrade took place but be using the updated protocol to execute and prove the transaction.
+     */
+    public txContext: TxContext,
     /**
      * The side-effect counter under which all side effects are non-revertible.
      */
@@ -69,6 +81,22 @@ export class PrivateCircuitPublicInputs {
      * The highest timestamp of a block in which the transaction can still be included.
      */
     public includeByTimestamp: UInt64,
+    /**
+     * The side effect counter at the start of this call.
+     */
+    public startSideEffectCounter: Fr,
+    /**
+     * The end side effect counter for this call.
+     */
+    public endSideEffectCounter: Fr,
+    /**
+     * The expected non revertible side effect counter for this call.
+     */
+    public expectedNonRevertibleSideEffectCounter: Fr,
+    /**
+     * The expected revertible side effect counter for this call.
+     */
+    public expectedRevertibleSideEffectCounter: Fr,
     /**
      * Read requests created by the corresponding function call.
      */
@@ -84,14 +112,6 @@ export class PrivateCircuitPublicInputs {
       KeyValidationRequestAndGenerator,
       typeof MAX_KEY_VALIDATION_REQUESTS_PER_CALL
     >,
-    /**
-     * New note hashes created by the corresponding function call.
-     */
-    public noteHashes: ClaimedLengthArray<NoteHash, typeof MAX_NOTE_HASHES_PER_CALL>,
-    /**
-     * New nullifiers created by the corresponding function call.
-     */
-    public nullifiers: ClaimedLengthArray<Nullifier, typeof MAX_NULLIFIERS_PER_CALL>,
     /**
      * Private call requests made within the current kernel iteration.
      */
@@ -104,6 +124,14 @@ export class PrivateCircuitPublicInputs {
      * Hash of the public teardown function.
      */
     public publicTeardownCallRequest: PublicCallRequest,
+    /**
+     * New note hashes created by the corresponding function call.
+     */
+    public noteHashes: ClaimedLengthArray<NoteHash, typeof MAX_NOTE_HASHES_PER_CALL>,
+    /**
+     * New nullifiers created by the corresponding function call.
+     */
+    public nullifiers: ClaimedLengthArray<Nullifier, typeof MAX_NULLIFIERS_PER_CALL>,
     /**
      * New L2 to L1 messages created by the corresponding function call.
      */
@@ -116,34 +144,6 @@ export class PrivateCircuitPublicInputs {
      * Hash of the contract class logs emitted in this function call.
      */
     public contractClassLogsHashes: ClaimedLengthArray<CountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_CALL>,
-    /**
-     * The side effect counter at the start of this call.
-     */
-    public startSideEffectCounter: Fr,
-    /**
-     * The end side effect counter for this call.
-     */
-    public endSideEffectCounter: Fr,
-    /**
-     * The expected non revertible side effect counter for this call.
-     */
-    public expectedNonRevertibleSideEffectCounter: Fr,
-    /**
-     * The expected revertible side effect counter for this call.
-     */
-    public expectedRevertibleSideEffectCounter: Fr,
-    /**
-     * Header of a block whose state is used during private execution (not the block the transaction is included in).
-     */
-    public anchorBlockHeader: BlockHeader,
-    /**
-     * Transaction context.
-     *
-     * Note: The chainId and version in the txContext are not redundant to the values in self.anchor_block_header.global_variables because
-     * they can be different in case of a protocol upgrade. In such a situation we could be using header from a block
-     * before the upgrade took place but be using the updated protocol to execute and prove the transaction.
-     */
-    public txContext: TxContext,
   ) {}
 
   /**
@@ -166,28 +166,28 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(CallContext),
       reader.readObject(Fr),
       reader.readObject(Fr),
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
       reader.readObject(Fr),
       reader.readBoolean(),
       reader.readUInt64(),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
       reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL)),
       reader.readObject(
         ClaimedLengthArrayFromBuffer(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
       ),
-      reader.readObject(ClaimedLengthArrayFromBuffer(NoteHash, MAX_NOTE_HASHES_PER_CALL)),
-      reader.readObject(ClaimedLengthArrayFromBuffer(Nullifier, MAX_NULLIFIERS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL)),
       reader.readObject(PublicCallRequest),
+      reader.readObject(ClaimedLengthArrayFromBuffer(NoteHash, MAX_NOTE_HASHES_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(Nullifier, MAX_NULLIFIERS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL)),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-      reader.readObject(BlockHeader),
-      reader.readObject(TxContext),
     );
   }
 
@@ -197,28 +197,28 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(CallContext),
       reader.readField(),
       reader.readField(),
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
       reader.readField(),
       reader.readBoolean(),
       reader.readU64(),
+      reader.readField(),
+      reader.readField(),
+      reader.readField(),
+      reader.readField(),
       reader.readObject(ClaimedLengthArrayFromFields(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL)),
       reader.readObject(
         ClaimedLengthArrayFromFields(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
       ),
-      reader.readObject(ClaimedLengthArrayFromFields(NoteHash, MAX_NOTE_HASHES_PER_CALL)),
-      reader.readObject(ClaimedLengthArrayFromFields(Nullifier, MAX_NULLIFIERS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL)),
       reader.readObject(PublicCallRequest),
+      reader.readObject(ClaimedLengthArrayFromFields(NoteHash, MAX_NOTE_HASHES_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(Nullifier, MAX_NULLIFIERS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL)),
-      reader.readField(),
-      reader.readField(),
-      reader.readField(),
-      reader.readField(),
-      reader.readObject(BlockHeader),
-      reader.readObject(TxContext),
     );
   }
 
@@ -231,26 +231,26 @@ export class PrivateCircuitPublicInputs {
       CallContext.empty(),
       Fr.ZERO,
       Fr.ZERO,
+      BlockHeader.empty(),
+      TxContext.empty(),
       Fr.ZERO,
       false,
       0n,
+      Fr.ZERO,
+      Fr.ZERO,
+      Fr.ZERO,
+      Fr.ZERO,
       ClaimedLengthArray.empty(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL),
       ClaimedLengthArray.empty(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL),
       ClaimedLengthArray.empty(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
-      ClaimedLengthArray.empty(NoteHash, MAX_NOTE_HASHES_PER_CALL),
-      ClaimedLengthArray.empty(Nullifier, MAX_NULLIFIERS_PER_CALL),
       ClaimedLengthArray.empty(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL),
       ClaimedLengthArray.empty(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL),
       PublicCallRequest.empty(),
+      ClaimedLengthArray.empty(NoteHash, MAX_NOTE_HASHES_PER_CALL),
+      ClaimedLengthArray.empty(Nullifier, MAX_NULLIFIERS_PER_CALL),
       ClaimedLengthArray.empty(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL),
       ClaimedLengthArray.empty(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL),
       ClaimedLengthArray.empty(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL),
-      Fr.ZERO,
-      Fr.ZERO,
-      Fr.ZERO,
-      Fr.ZERO,
-      BlockHeader.empty(),
-      TxContext.empty(),
     );
   }
 
@@ -259,26 +259,26 @@ export class PrivateCircuitPublicInputs {
       this.callContext.isEmpty() &&
       this.argsHash.isZero() &&
       this.returnsHash.isZero() &&
+      this.anchorBlockHeader.isEmpty() &&
+      this.txContext.isEmpty() &&
       this.minRevertibleSideEffectCounter.isZero() &&
       !this.isFeePayer &&
       !this.includeByTimestamp &&
+      this.startSideEffectCounter.isZero() &&
+      this.endSideEffectCounter.isZero() &&
+      this.expectedNonRevertibleSideEffectCounter.isZero() &&
+      this.expectedRevertibleSideEffectCounter.isZero() &&
       this.noteHashReadRequests.isEmpty() &&
       this.nullifierReadRequests.isEmpty() &&
       this.keyValidationRequestsAndGenerators.isEmpty() &&
-      this.noteHashes.isEmpty() &&
-      this.nullifiers.isEmpty() &&
       this.privateCallRequests.isEmpty() &&
       this.publicCallRequests.isEmpty() &&
       this.publicTeardownCallRequest.isEmpty() &&
+      this.noteHashes.isEmpty() &&
+      this.nullifiers.isEmpty() &&
       this.l2ToL1Msgs.isEmpty() &&
       this.privateLogs.isEmpty() &&
-      this.contractClassLogsHashes.isEmpty() &&
-      this.startSideEffectCounter.isZero() &&
-      this.endSideEffectCounter.isZero() &&
-      this.expectedNonRevertibleSideEffectCounter.isZero() &&
-      this.expectedRevertibleSideEffectCounter.isZero() &&
-      this.anchorBlockHeader.isEmpty() &&
-      this.txContext.isEmpty()
+      this.contractClassLogsHashes.isEmpty()
     );
   }
 
@@ -292,26 +292,26 @@ export class PrivateCircuitPublicInputs {
       fields.callContext,
       fields.argsHash,
       fields.returnsHash,
+      fields.anchorBlockHeader,
+      fields.txContext,
       fields.minRevertibleSideEffectCounter,
       fields.isFeePayer,
       fields.includeByTimestamp,
+      fields.startSideEffectCounter,
+      fields.endSideEffectCounter,
+      fields.expectedNonRevertibleSideEffectCounter,
+      fields.expectedRevertibleSideEffectCounter,
       fields.noteHashReadRequests,
       fields.nullifierReadRequests,
       fields.keyValidationRequestsAndGenerators,
-      fields.noteHashes,
-      fields.nullifiers,
       fields.privateCallRequests,
       fields.publicCallRequests,
       fields.publicTeardownCallRequest,
+      fields.noteHashes,
+      fields.nullifiers,
       fields.l2ToL1Msgs,
       fields.privateLogs,
       fields.contractClassLogsHashes,
-      fields.startSideEffectCounter,
-      fields.endSideEffectCounter,
-      fields.expectedNonRevertibleSideEffectCounter,
-      fields.expectedRevertibleSideEffectCounter,
-      fields.anchorBlockHeader,
-      fields.txContext,
     ] as const;
   }
 
@@ -326,26 +326,26 @@ export class PrivateCircuitPublicInputs {
       this.callContext,
       this.argsHash,
       this.returnsHash,
+      this.anchorBlockHeader,
+      this.txContext,
       this.minRevertibleSideEffectCounter,
       this.isFeePayer,
       bigintToUInt64BE(this.includeByTimestamp),
+      this.startSideEffectCounter,
+      this.endSideEffectCounter,
+      this.expectedNonRevertibleSideEffectCounter,
+      this.expectedRevertibleSideEffectCounter,
       this.noteHashReadRequests,
       this.nullifierReadRequests,
       this.keyValidationRequestsAndGenerators,
-      this.noteHashes,
-      this.nullifiers,
       this.privateCallRequests,
       this.publicCallRequests,
       this.publicTeardownCallRequest,
+      this.noteHashes,
+      this.nullifiers,
       this.l2ToL1Msgs,
       this.privateLogs,
       this.contractClassLogsHashes,
-      this.startSideEffectCounter,
-      this.endSideEffectCounter,
-      this.expectedNonRevertibleSideEffectCounter,
-      this.expectedRevertibleSideEffectCounter,
-      this.anchorBlockHeader,
-      this.txContext,
     ]);
   }
 

package/src/keys/derivation.ts

@@ -10,8 +10,8 @@ import type { KeyPrefix } from './key_types.js';
 import { PublicKeys } from './public_keys.js';
 import { getKeyGenerator } from './utils.js';
 
-export function computeAppNullifierSecretKey(masterNullifierSecretKey: GrumpkinScalar, app: AztecAddress): Promise<Fr> {
-  return computeAppSecretKey(masterNullifierSecretKey, app, 'n'); // 'n' is the key prefix for nullifier secret key
+export function computeAppNullifierHidingKey(masterNullifierHidingKey: GrumpkinScalar, app: AztecAddress): Promise<Fr> {
+  return computeAppSecretKey(masterNullifierHidingKey, app, 'n'); // 'n' is the key prefix for nullifier hiding key
 }
 
 export function computeAppSecretKey(skM: GrumpkinScalar, app: AztecAddress, keyPrefix: KeyPrefix): Promise<Fr> {
@@ -26,8 +26,8 @@ export async function computeOvskApp(ovsk: GrumpkinScalar, app: AztecAddress): P
   return GrumpkinScalar.fromBuffer(ovskAppFr.toBuffer());
 }
 
-export function deriveMasterNullifierSecretKey(secretKey: Fr): GrumpkinScalar {
-  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.NSK_M]);
+export function deriveMasterNullifierHidingKey(secretKey: Fr): GrumpkinScalar {
+  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.NHK_M]);
 }
 
 export function deriveMasterIncomingViewingSecretKey(secretKey: Fr): GrumpkinScalar {
@@ -93,15 +93,15 @@ export function derivePublicKeyFromSecretKey(secretKey: Fq) {
  * @returns The derived keys.
  */
 export async function deriveKeys(secretKey: Fr) {
-  // First we derive master secret keys -  we use sha512 here because this derivation will never take place
+  // First we derive master secret/hiding keys -  we use sha512 here because this derivation will never take place
   // in a circuit
-  const masterNullifierSecretKey = deriveMasterNullifierSecretKey(secretKey);
+  const masterNullifierHidingKey = deriveMasterNullifierHidingKey(secretKey);
   const masterIncomingViewingSecretKey = deriveMasterIncomingViewingSecretKey(secretKey);
   const masterOutgoingViewingSecretKey = deriveMasterOutgoingViewingSecretKey(secretKey);
   const masterTaggingSecretKey = sha512ToGrumpkinScalar([secretKey, GeneratorIndex.TSK_M]);
 
   // Then we derive master public keys
-  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierSecretKey);
+  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierHidingKey);
   const masterIncomingViewingPublicKey = await derivePublicKeyFromSecretKey(masterIncomingViewingSecretKey);
   const masterOutgoingViewingPublicKey = await derivePublicKeyFromSecretKey(masterOutgoingViewingSecretKey);
   const masterTaggingPublicKey = await derivePublicKeyFromSecretKey(masterTaggingSecretKey);
@@ -115,7 +115,7 @@ export async function deriveKeys(secretKey: Fr) {
   );
 
   return {
-    masterNullifierSecretKey,
+    masterNullifierHidingKey,
     masterIncomingViewingSecretKey,
     masterOutgoingViewingSecretKey,
     masterTaggingSecretKey,

package/src/keys/key_types.ts

@@ -1,5 +1,5 @@
 import type { GeneratorIndex } from '@aztec/constants';
 
-export type KeyGenerator = GeneratorIndex.NSK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
+export type KeyGenerator = GeneratorIndex.NHK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
 export type KeyPrefix = 'n' | 'iv' | 'ov' | 't';
 export const KEY_PREFIXES: KeyPrefix[] = ['n', 'iv', 'ov', 't'];

package/src/keys/utils.ts

@@ -3,7 +3,11 @@ import { GeneratorIndex } from '@aztec/constants';
 import type { KeyGenerator, KeyPrefix } from './key_types.js';
 
 export function getKeyGenerator(prefix: KeyPrefix): KeyGenerator {
-  // We get enum key by capitalizing key prefix and concatenating it with 'SK_M'
-  const enumKey = `${prefix.toUpperCase()}SK_M`;
-  return GeneratorIndex[enumKey as keyof typeof GeneratorIndex] as KeyGenerator;
+  const map: Record<KeyPrefix, KeyGenerator> = {
+    n: GeneratorIndex.NHK_M,
+    iv: GeneratorIndex.IVSK_M,
+    ov: GeneratorIndex.OVSK_M,
+    t: GeneratorIndex.TSK_M,
+  };
+  return map[prefix];
 }

package/src/l1-contracts/slash_factory.ts

@@ -41,6 +41,7 @@ export class SlashFactoryContract {
 
     return {
       to: this.contract.address,
+      abi: SlashFactoryAbi,
       data: encodeFunctionData({
         abi: SlashFactoryAbi,
         functionName: 'createSlashPayload',

package/src/logs/index.ts

@@ -1,4 +1,3 @@
-export * from './log_with_tx_data.js';
 export * from './directional_app_tagging_secret.js';
 export * from './pre_tag.js';
 export * from './contract_class_log.js';
@@ -13,3 +12,5 @@ export * from './shared_secret_derivation.js';
 export * from './tx_scoped_l2_log.js';
 export * from './message_context.js';
 export * from './debug_log.js';
+export * from './tag.js';
+export * from './siloed_tag.js';

package/src/logs/log_id.ts

@@ -1,23 +1,24 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
+import { BlockHash } from '../block/block_hash.js';
 import { schemas } from '../schemas/index.js';
+import { TxHash } from '../tx/tx_hash.js';
 
 /** A globally unique log id. */
 export class LogId {
-  /**
-   * Parses a log id from a string.
-   * @param blockNumber - The block number.
-   * @param txIndex - The transaction index.
-   * @param logIndex - The log index.
-   */
   constructor(
     /** The block number the log was emitted in. */
     public readonly blockNumber: BlockNumber,
+    /** The hash of the block the log was emitted in. */
+    public readonly blockHash: BlockHash,
+    /** The hash of the transaction the log was emitted in. */
+    public readonly txHash: TxHash,
     /** The index of a tx in a block the log was emitted in. */
     public readonly txIndex: number,
     /** The index of a log the tx was emitted in. */
@@ -37,6 +38,8 @@ export class LogId {
   static random() {
     return new LogId(
       BlockNumber(Math.floor(Math.random() * 1000) + 1),
+      BlockHash.random(),
+      TxHash.random(),
       Math.floor(Math.random() * 1000),
       Math.floor(Math.random() * 100),
     );
@@ -46,10 +49,15 @@ export class LogId {
     return z
       .object({
         blockNumber: BlockNumberSchema,
+        blockHash: BlockHash.schema,
+        txHash: TxHash.schema,
         txIndex: schemas.Integer,
         logIndex: schemas.Integer,
       })
-      .transform(({ blockNumber, txIndex, logIndex }) => new LogId(blockNumber, txIndex, logIndex));
+      .transform(
+        ({ blockNumber, blockHash, txHash, txIndex, logIndex }) =>
+          new LogId(blockNumber, blockHash, txHash, txIndex, logIndex),
+      );
   }
 
   /**
@@ -59,6 +67,8 @@ export class LogId {
   public toBuffer(): Buffer {
     return Buffer.concat([
       toBufferBE(BigInt(this.blockNumber), 4),
+      this.blockHash.toBuffer(),
+      this.txHash.toBuffer(),
       toBufferBE(BigInt(this.txIndex), 4),
       toBufferBE(BigInt(this.logIndex), 4),
     ]);
@@ -73,10 +83,12 @@ export class LogId {
     const reader = BufferReader.asReader(buffer);
 
     const blockNumber = BlockNumber(reader.readNumber());
+    const blockHash = new BlockHash(reader.readObject(Fr));
+    const txHash = reader.readObject(TxHash);
     const txIndex = reader.readNumber();
     const logIndex = reader.readNumber();
 
-    return new LogId(blockNumber, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
   }
 
   /**
@@ -84,7 +96,7 @@ export class LogId {
    * @returns A string representation of the log id.
    */
   public toString(): string {
-    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}`;
+    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}-${this.blockHash.toString()}-${this.txHash.toString()}`;
   }
 
   /**
@@ -93,12 +105,14 @@ export class LogId {
    * @returns A log id.
    */
   static fromString(data: string): LogId {
-    const [rawBlockNumber, rawTxIndex, rawLogIndex] = data.split('-');
+    const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash, rawTxHash] = data.split('-');
     const blockNumber = BlockNumber(Number(rawBlockNumber));
+    const blockHash = BlockHash.fromString(rawBlockHash);
+    const txHash = TxHash.fromString(rawTxHash);
     const txIndex = Number(rawTxIndex);
     const logIndex = Number(rawLogIndex);
 
-    return new LogId(blockNumber, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
   }
 
   /**
@@ -106,6 +120,6 @@ export class LogId {
    * @returns A human readable representation of the log id.
    */
   public toHumanReadable(): string {
-    return `logId: (blockNumber: ${this.blockNumber}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
+    return `logId: (blockNumber: ${this.blockNumber}, blockHash: ${this.blockHash.toString()}, txHash: ${this.txHash.toString()}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
   }
 }

package/src/logs/private_log.ts

@@ -59,7 +59,8 @@ export class PrivateLog {
   }
 
   isEmpty() {
-    return this.fields.every(f => f.isZero());
+    // Faster to check emittedLength than compare all fields against zero
+    return this.emittedLength === 0;
   }
 
   static empty() {

package/src/logs/siloed_tag.ts

@@ -0,0 +1,45 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { ZodFor } from '@aztec/foundation/schemas';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { schemas } from '../schemas/schemas.js';
+import type { Tag } from './tag.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+
+/** Branding to ensure fields are not interchangeable types. */
+export interface SiloedTag {
+  /** Brand. */
+  _branding: 'SiloedTag';
+}
+
+/**
+ * Represents a tag used in private log as it "appears on the chain" - that is the tag is siloed with a contract
+ * address that emitted the log.
+ */
+export class SiloedTag {
+  constructor(public readonly value: Fr) {}
+
+  static async compute(tag: Tag, app: AztecAddress): Promise<SiloedTag> {
+    const siloedTag = await poseidon2HashWithSeparator([app, tag.value], GeneratorIndex.PRIVATE_LOG_FIRST_FIELD);
+    return new SiloedTag(siloedTag);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+
+  toJSON(): string {
+    return this.value.toString();
+  }
+
+  equals(other: SiloedTag): boolean {
+    return this.value.equals(other.value);
+  }
+
+  static get schema(): ZodFor<SiloedTag> {
+    return schemas.Fr.transform((fr: Fr) => new SiloedTag(fr));
+  }
+}

package/src/logs/tag.ts

@@ -0,0 +1,42 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { ZodFor } from '@aztec/foundation/schemas';
+
+import { schemas } from '../schemas/schemas.js';
+import type { PreTag } from './pre_tag.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+
+export interface Tag {
+  /** Brand. */
+  _branding: 'Tag';
+}
+
+/**
+ * Represents a tag of a private log. This is not the tag that "appears" on the chain as this tag is first siloed
+ * with a contract address by kernels before being included in the final log.
+ */
+export class Tag {
+  constructor(public readonly value: Fr) {}
+
+  static async compute(preTag: PreTag): Promise<Tag> {
+    const tag = await poseidon2Hash([preTag.secret.value, preTag.index]);
+    return new Tag(tag);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+
+  toJSON(): string {
+    return this.value.toString();
+  }
+
+  equals(other: Tag): boolean {
+    return this.value.equals(other.value);
+  }
+
+  static get schema(): ZodFor<Tag> {
+    return schemas.Fr.transform((fr: Fr) => new Tag(fr));
+  }
+}