@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/l1-contracts/slash_factory.ts

@@ -0,0 +1,177 @@
+import { type L1TxRequest, type ViemClient, tryExtractEvent } from '@aztec/ethereum';
+import { maxBigint } from '@aztec/foundation/bigint';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { SlashFactoryAbi } from '@aztec/l1-artifacts/SlashFactoryAbi';
+
+import { type GetContractReturnType, type Hex, type Log, encodeFunctionData, getContract } from 'viem';
+
+import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import {
+  OffenseToBigInt,
+  type SlashPayload,
+  type ValidatorSlash,
+  type ValidatorSlashOffense,
+  bigIntToOffense,
+} from '../slashing/index.js';
+
+export class SlashFactoryContract {
+  private readonly logger = createLogger('contracts:slash_factory');
+  private readonly contract: GetContractReturnType<typeof SlashFactoryAbi, ViemClient>;
+
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    this.contract = getContract({
+      address: typeof address === 'string' ? address : address.toString(),
+      abi: SlashFactoryAbi,
+      client,
+    });
+  }
+
+  public get address() {
+    return EthAddress.fromString(this.contract.address);
+  }
+
+  public buildCreatePayloadRequest(slashes: ValidatorSlash[]): L1TxRequest {
+    const sorted = this.sortSlashes(slashes);
+
+    return {
+      to: this.contract.address,
+      data: encodeFunctionData({
+        abi: SlashFactoryAbi,
+        functionName: 'createSlashPayload',
+        args: [
+          sorted.map(d => d.validator.toString()),
+          sorted.map(d => d.amount),
+          sorted.map(d => d.offenses.map(packValidatorSlashOffense)),
+        ],
+      }),
+    };
+  }
+
+  /** Tries to extract a SlashPayloadCreated event from the given logs. */
+  public tryExtractSlashPayloadCreatedEvent(logs: Log[]) {
+    return tryExtractEvent(logs, this.address.toString(), SlashFactoryAbi, 'SlashPayloadCreated');
+  }
+
+  public async getSlashPayloadCreatedEvents(): Promise<SlashPayload[]> {
+    const events = await this.contract.getEvents.SlashPayloadCreated();
+    return Promise.all(
+      events.map(async event => {
+        const { validators, amounts, offenses } = event.args;
+        const slashes: ValidatorSlash[] = validators!.map((validator, i) => ({
+          validator: EthAddress.fromString(validator),
+          amount: amounts![i],
+          offenses: offenses![i].map(unpackValidatorSlashOffense),
+        }));
+
+        const block = await this.client.getBlock({ blockNumber: event.blockNumber, includeTransactions: false });
+        return { address: EthAddress.fromString(event.args.payloadAddress!), slashes, timestamp: block.timestamp };
+      }),
+    );
+  }
+
+  /**
+   * Searches for a slash payload in the events emitted by the contract.
+   * This method cannot query for historical payload events, it queries for payloads that have not yet expired.
+   * @param payloadAddress The address of the payload to search for.
+   * @param constants The L1 rollup constants needed for time calculations.
+   */
+  public async getSlashPayloadFromEvents(
+    payloadAddress: EthAddress,
+    settings: {
+      logsBatchSize?: number;
+      slashingRoundSize: number;
+      slashingPayloadLifetimeInRounds: number;
+    } & Pick<L1RollupConstants, 'slotDuration' | 'ethereumSlotDuration'>,
+  ): Promise<Omit<SlashPayload, 'votes'> | undefined> {
+    // We query for the log where the payload was emitted walking backwards until we go past payload expiration time
+    // Note that all log queries require a block range, and RPC providers cap the max range (eg quicknode is 10k blocks).
+    const { slashingRoundSize, slashingPayloadLifetimeInRounds, slotDuration, ethereumSlotDuration } = settings;
+    const currentBlockNumber = await this.client.getBlockNumber({ cacheTime: 0 });
+
+    // Why the +1 below? Just for good measure. Better err on the safe side.
+    const earliestBlockNumber = maxBigint(
+      0n,
+      currentBlockNumber -
+        ((BigInt(slashingPayloadLifetimeInRounds) + 1n) * BigInt(slashingRoundSize) * BigInt(slotDuration)) /
+          BigInt(ethereumSlotDuration),
+    );
+
+    this.logger.trace(
+      `Starting search for slash payload ${payloadAddress} from block ${currentBlockNumber} with earliest block ${earliestBlockNumber}`,
+    );
+    const batchSize = BigInt(settings.logsBatchSize ?? 10000);
+    let toBlock = currentBlockNumber;
+
+    do {
+      const fromBlock = maxBigint(earliestBlockNumber, toBlock - batchSize);
+      this.logger.trace(`Searching for slash payload ${payloadAddress} in blocks ${fromBlock} to ${toBlock}`);
+      const logs = await this.contract.getEvents.SlashPayloadCreated(
+        { payloadAddress: payloadAddress.toString() },
+        { fromBlock, toBlock, strict: true },
+      );
+
+      // We found the payload, return it
+      if (logs.length > 0) {
+        const log = logs[0];
+        const { validators, amounts, offenses } = log.args;
+
+        // Convert the data to our internal types
+        const slashes: ValidatorSlash[] = validators!.map((validator, i) => ({
+          validator: EthAddress.fromString(validator),
+          amount: amounts![i],
+          offenses: offenses![i].map(unpackValidatorSlashOffense),
+        }));
+
+        // Get the timestamp from the block
+        const block = await this.client.getBlock({ blockNumber: log.blockNumber, includeTransactions: false });
+
+        return { address: payloadAddress, slashes, timestamp: block.timestamp };
+      }
+
+      // If not found, we go back one batch
+      toBlock -= batchSize;
+    } while (toBlock > earliestBlockNumber);
+
+    return undefined;
+  }
+
+  public async getAddressAndIsDeployed(
+    slashes: ValidatorSlash[],
+  ): Promise<{ address: EthAddress; salt: Hex; isDeployed: boolean }> {
+    const sortedSlashes = this.sortSlashes(slashes);
+    const [address, salt, isDeployed] = await this.contract.read.getAddressAndIsDeployed([
+      sortedSlashes.map(s => s.validator.toString()),
+      sortedSlashes.map(s => s.amount),
+      sortedSlashes.map(s => s.offenses.map(packValidatorSlashOffense)),
+    ]);
+    return { address: EthAddress.fromString(address), salt, isDeployed };
+  }
+
+  private sortSlashes(slashes: ValidatorSlash[]): ValidatorSlash[] {
+    const offenseSorter = (a: ValidatorSlashOffense, b: ValidatorSlashOffense) => {
+      return a.epochOrSlot === b.epochOrSlot ? a.offenseType - b.offenseType : Number(a.epochOrSlot - b.epochOrSlot);
+    };
+    return [...slashes]
+      .map(slash => ({ ...slash, offenses: [...slash.offenses].sort(offenseSorter) }))
+      .sort((a, b) => a.validator.toString().localeCompare(b.validator.toString()));
+  }
+}
+
+export function packValidatorSlashOffense(offense: ValidatorSlashOffense): bigint {
+  const offenseId = OffenseToBigInt[offense.offenseType];
+  if (offenseId > (1 << 8) - 1) {
+    throw new Error(`Offense type ${offense.offenseType} cannot be packed into 8 bits`);
+  }
+  return (offenseId << 120n) + offense.epochOrSlot;
+}
+
+export function unpackValidatorSlashOffense(packed: bigint): ValidatorSlashOffense {
+  const offenseId = (packed >> 120n) & 0xffn;
+  const epochOrSlot = packed & ((1n << 120n) - 1n);
+  const offenseType = bigIntToOffense(offenseId);
+  return { epochOrSlot, offenseType };
+}

package/src/logs/contract_class_log.ts

@@ -1,40 +1,71 @@
-import { CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { CONTRACT_CLASS_LOG_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
-export class ContractClassLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_SIZE_IN_FIELDS;
-  // Keeps original first field pre-siloing. Only set by silo().
-  public unsiloedFirstField?: Fr | undefined;
-
+export class ContractClassLogFields {
   // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-  // public fields: Tuple<Fr, typeof CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS>
-  constructor(public contractAddress: AztecAddress, public fields: Fr[]) {
-    if (fields.length !== CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS) {
+  // public fields: Tuple<Fr, typeof CONTRACT_CLASS_LOG_SIZE_IN_FIELDS>
+  constructor(public fields: Fr[]) {
+    if (fields.length !== CONTRACT_CLASS_LOG_SIZE_IN_FIELDS) {
       throw new Error(
-        `Invalid number of fields for ContractClassLog. Expected ${CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS}, got ${fields.length}`,
+        `Invalid number of fields for ContractClassLog. Expected ${CONTRACT_CLASS_LOG_SIZE_IN_FIELDS}, got ${fields.length}`,
       );
     }
   }
 
+  static get schema() {
+    return z
+      .object({
+        fields: z.array(schemas.Fr).refine(arr => arr.length === CONTRACT_CLASS_LOG_SIZE_IN_FIELDS),
+      })
+      .transform(({ fields }) => new ContractClassLogFields(fields));
+  }
+
   toFields(): Fr[] {
-    return [this.contractAddress.toField(), ...this.fields];
+    return this.fields;
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // return new ContractClassLog(reader.readFieldArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS));
-    return new ContractClassLog(
-      reader.readObject(AztecAddress),
-      Array.from({ length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS }, () => reader.readField()),
+    // reader.readFieldArray(CONTRACT_CLASS_LOG_LENGTH);
+    return new ContractClassLogFields(
+      Array.from({ length: CONTRACT_CLASS_LOG_SIZE_IN_FIELDS }, () => reader.readField()),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.fields);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+    // reader.readArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, Fr)
+    return new ContractClassLogFields(
+      Array.from({ length: CONTRACT_CLASS_LOG_SIZE_IN_FIELDS }, () => reader.readObject(Fr)),
+    );
+  }
+
+  equals(other: ContractClassLogFields) {
+    return this.fields.every((f, i) => f.equals(other.fields[i]));
+  }
+
+  getEmittedFields(emittedLength: number) {
+    return this.fields.slice(0, emittedLength);
+  }
+
+  static fromEmittedFields(emittedFields: Fr[]) {
+    return new ContractClassLogFields(
+      emittedFields.concat(Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - emittedFields.length).fill(Fr.ZERO)),
     );
   }
 
@@ -43,89 +74,129 @@ export class ContractClassLog {
   }
 
   static empty() {
-    return new ContractClassLog(AztecAddress.ZERO, new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS).fill(Fr.ZERO));
+    return new ContractClassLogFields(Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS).fill(Fr.ZERO));
   }
 
-  toBuffer(): Buffer {
-    return serializeToBuffer([this.contractAddress, this.fields]);
+  static random(emittedLength = CONTRACT_CLASS_LOG_SIZE_IN_FIELDS) {
+    return new ContractClassLogFields(
+      Array.from({ length: emittedLength }, () => Fr.random()).concat(
+        Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - emittedLength).fill(Fr.ZERO),
+      ),
+    );
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // reader.readArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, Fr);
-    const address = reader.readObject(AztecAddress);
-    const fields = Array.from({ length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS }, () =>
-      reader.remainingBytes() == 0 ? Fr.ZERO : Fr.fromBuffer(reader),
-    );
-    return new ContractClassLog(address, fields);
+  async hash() {
+    return await poseidon2Hash(this.fields);
   }
 
   clone() {
-    return ContractClassLog.fromBuffer(this.toBuffer());
+    return ContractClassLogFields.fromBuffer(this.toBuffer());
   }
+}
 
-  static async random() {
-    // NB: Using half the maximum number of fields per log because max fields keeps overfilling blobs in tests.
-    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // makeTuple(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, Fr.random);
-    const fields = Array.from({ length: Math.ceil(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2) }, () => Fr.random());
-    return new ContractClassLog(
-      await AztecAddress.random(),
-      fields.concat(Array.from({ length: Math.floor(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2) }, () => Fr.ZERO)),
+export class ContractClassLog {
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_LENGTH;
+
+  constructor(
+    public contractAddress: AztecAddress,
+    public fields: ContractClassLogFields,
+    public emittedLength: number,
+  ) {}
+
+  static from(fields: FieldsOf<ContractClassLog>) {
+    return new ContractClassLog(fields.contractAddress, fields.fields, fields.emittedLength);
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields([this.contractAddress, this.fields, this.emittedLength]);
+  }
+
+  equals(other: ContractClassLog) {
+    return (
+      this.contractAddress.equals(other.contractAddress) &&
+      this.fields.equals(other.fields) &&
+      this.emittedLength === other.emittedLength
     );
   }
 
-  getEmittedLength() {
-    // This assumes that we cut trailing zeroes from the end of the log. In ts, these will always be added back.
-    // Does not include address or length prefix.
-    // Note: Unlike public logs, address is not included here because it is not included in the log itself.
-    return this.getEmittedFields().length;
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new ContractClassLog(
+      reader.readObject(AztecAddress),
+      reader.readObject(ContractClassLogFields),
+      reader.readU32(),
+    );
   }
 
   getEmittedFields() {
-    const lastNonZeroIndex = this.fields.findLastIndex(f => !f.isZero());
-    return this.fields.slice(0, lastNonZeroIndex + 1);
+    return this.fields.getEmittedFields(this.emittedLength);
   }
 
-  setUnsiloedFirstField(field: Fr) {
-    this.unsiloedFirstField = field;
+  toBlobFields(): Fr[] {
+    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
   }
 
-  toUnsiloed() {
-    if (this.unsiloedFirstField) {
-      return new ContractClassLog(this.contractAddress, [this.unsiloedFirstField].concat(this.fields.slice(1)));
-    } else {
-      return this;
-    }
+  static fromBlobFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const emittedLength = reader.readU32();
+    const contractAddress = reader.readObject(AztecAddress);
+    const emittedFields = reader.readFieldArray(emittedLength);
+    return new ContractClassLog(
+      contractAddress,
+      ContractClassLogFields.fromEmittedFields(emittedFields),
+      emittedLength,
+    );
   }
 
-  async silo() {
-    const innerLog = this.clone();
-    if (innerLog.contractAddress.isZero()) {
-      return innerLog;
-    }
-    innerLog.setUnsiloedFirstField(innerLog.fields[0]);
-    innerLog.fields[0] = await poseidon2Hash([innerLog.contractAddress, innerLog.fields[0]]);
-    return innerLog;
+  isEmpty() {
+    return this.contractAddress.isZero() && this.fields.isEmpty() && this.emittedLength === 0;
+  }
+
+  static empty() {
+    return new ContractClassLog(AztecAddress.ZERO, ContractClassLogFields.empty(), 0);
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.contractAddress, this.fields, this.emittedLength]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    const address = reader.readObject(AztecAddress);
+    const fields = ContractClassLogFields.fromBuffer(reader);
+    const emittedLength = reader.readNumber();
+    return new ContractClassLog(address, fields, emittedLength);
+  }
+
+  static async random() {
+    // NB: Using half the maximum number of fields per log because max fields keeps overfilling blobs in tests.
+    const emittedLength = Math.ceil(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS / 2);
+    return new ContractClassLog(
+      await AztecAddress.random(),
+      ContractClassLogFields.random(emittedLength),
+      emittedLength,
+    );
   }
 
   async hash() {
-    return await poseidon2Hash(this.fields);
+    return await this.fields.hash();
   }
 
   static get schema() {
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        fields: z.array(schemas.Fr),
+        fields: ContractClassLogFields.schema,
+        emittedLength: z.number(),
       })
-      .transform(({ contractAddress, fields }) => ContractClassLog.fromFields([contractAddress.toField(), ...fields]));
+      .transform(ContractClassLog.from);
   }
 
   [inspect.custom](): string {
     return `ContractClassLog {
-      fields: [${this.fields.map((x: Fr) => inspect(x)).join(', ')}],
+      contractAddress: ${this.contractAddress.toString()},
+      emittedLength: ${this.emittedLength},
+      fields: [${this.fields.fields.map((x: Fr) => inspect(x)).join(', ')}],
     }`;
   }
 }

package/src/logs/index.ts

@@ -3,9 +3,11 @@ export * from './indexed_tagging_secret.js';
 export * from './contract_class_log.js';
 export * from './public_log.js';
 export * from './private_log.js';
+export * from './pending_tagged_log.js';
 export * from './log_id.js';
 export * from './log_filter.js';
 export * from './extended_public_log.js';
 export * from './extended_contract_class_log.js';
-export * from './l1_payload/index.js';
+export * from './shared_secret_derivation.js';
 export * from './tx_scoped_l2_log.js';
+export * from './message_context.js';

package/src/logs/indexed_tagging_secret.ts

@@ -4,7 +4,10 @@ import { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '../aztec-address/index.js';
 
 export class IndexedTaggingSecret {
-  constructor(public appTaggingSecret: Fr, public index: number) {
+  constructor(
+    public appTaggingSecret: Fr,
+    public index: number,
+  ) {
     if (index < 0) {
       throw new Error('IndexedTaggingSecret index out of bounds');
     }

package/src/logs/log_with_tx_data.ts

@@ -1,27 +1,47 @@
-import { MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN, PUBLIC_LOG_PLAINTEXT_LEN } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
+import { TxHash } from '@aztec/stdlib/tx';
 
-// TypeScript representation of the Noir aztec::oracle::note_discovery::LogWithTxData struct. This is used as a response
-// for PXE's custom getLogByTag oracle.
-export class LogWithTxData {
+// TypeScript representation of the Noir aztec::oracle::message_processing::LogWithTxData<N> struct. This is used as a
+// response for PXE's custom getPublicLogByTag and getPrivateLogByTag oracles.
+class LogWithTxData<N extends number> {
   constructor(
-    public logContent: Fr[],
-    public txHash: Fr,
+    public logPayload: Fr[],
+    public txHash: TxHash,
     public uniqueNoteHashesInTx: Fr[],
     public firstNullifierInTx: Fr,
+    private maxLogContentLength: N,
   ) {}
 
   toNoirSerialization(): (Fr | Fr[])[] {
     return [
-      ...toBoundedVecSerialization(this.logContent, PUBLIC_LOG_DATA_SIZE_IN_FIELDS),
-      this.txHash,
+      ...toBoundedVecSerialization(this.logPayload, this.maxLogContentLength),
+      this.txHash.hash,
       ...toBoundedVecSerialization(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
       this.firstNullifierInTx,
     ];
   }
+}
+
+// This is used as a response for PXE's custom getPublicLogByTag oracle.
+export class PublicLogWithTxData extends LogWithTxData<typeof PUBLIC_LOG_PLAINTEXT_LEN> {
+  constructor(logContent: Fr[], txHash: TxHash, uniqueNoteHashesInTx: Fr[], firstNullifierInTx: Fr) {
+    super(logContent, txHash, uniqueNoteHashesInTx, firstNullifierInTx, PUBLIC_LOG_PLAINTEXT_LEN);
+  }
+
+  static noirSerializationOfEmpty(): (Fr | Fr[])[] {
+    return new PublicLogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();
+  }
+}
+
+// This is used as a response for PXE's custom getPrivateLogByTag oracle.
+export class PrivateLogWithTxData extends LogWithTxData<typeof PRIVATE_LOG_CIPHERTEXT_LEN> {
+  constructor(logContent: Fr[], txHash: TxHash, uniqueNoteHashesInTx: Fr[], firstNullifierInTx: Fr) {
+    super(logContent, txHash, uniqueNoteHashesInTx, firstNullifierInTx, PRIVATE_LOG_CIPHERTEXT_LEN);
+  }
 
   static noirSerializationOfEmpty(): (Fr | Fr[])[] {
-    return new LogWithTxData([], new Fr(0), [], new Fr(0)).toNoirSerialization();
+    return new PrivateLogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();
   }
 }
 

package/src/logs/message_context.ts

@@ -0,0 +1,62 @@
+import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import type { TxEffect } from '../tx/tx_effect.js';
+import type { TxHash } from '../tx/tx_hash.js';
+
+/**
+ * Additional information needed to process a message.
+ *
+ * All messages exist in the context of a transaction, and information about that transaction is typically required
+ * in order to perform validation, store results, etc. For example, messages containing notes require knowledge of note
+ * hashes and the first nullifier in order to find the note's nonce.
+ *
+ * A TS version of `message_context.nr`.
+ */
+export class MessageContext {
+  constructor(
+    public txHash: TxHash,
+    public uniqueNoteHashesInTx: Fr[],
+    public firstNullifierInTx: Fr,
+    public recipient: AztecAddress,
+  ) {}
+
+  toFields(): Fr[] {
+    return [
+      this.txHash.hash,
+      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
+      this.firstNullifierInTx,
+      this.recipient.toField(),
+    ];
+  }
+
+  toNoirStruct() {
+    /* eslint-disable camelcase */
+    return {
+      tx_hash: this.txHash.hash,
+      unique_note_hashes_in_tx: this.uniqueNoteHashesInTx,
+      first_nullifier_in_tx: this.firstNullifierInTx,
+      recipient: this.recipient,
+    };
+    /* eslint-enable camelcase */
+  }
+
+  static fromTxEffectAndRecipient(txEffect: TxEffect, recipient: AztecAddress): MessageContext {
+    return new MessageContext(txEffect.txHash, txEffect.noteHashes, txEffect.nullifiers[0], recipient);
+  }
+}
+
+/**
+ * Helper function to serialize a bounded vector according to Noir's BoundedVec format
+ * @param values - The values to serialize
+ * @param maxLength - The maximum length of the bounded vector
+ * @returns The serialized bounded vector as Fr[]
+ * @dev Copied over from pending_tagged_log.ts.
+ */
+function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
+  const lengthDiff = maxLength - values.length;
+  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
+  const storage = values.concat(zeroPaddingArray);
+  return [...storage, new Fr(values.length)];
+}

package/src/logs/pending_tagged_log.ts

@@ -0,0 +1,41 @@
+import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import type { TxHash } from '../tx/tx_hash.js';
+import { MessageContext } from './message_context.js';
+
+/**
+ * Represents a pending tagged log as it is stored in the pending tagged log array to which the fetchTaggedLogs oracle
+ * inserts found private logs. A TS version of `pending_tagged_log.nr`.
+ */
+export class PendingTaggedLog {
+  private context: MessageContext;
+
+  constructor(
+    public log: Fr[],
+    txHash: TxHash,
+    uniqueNoteHashesInTx: Fr[],
+    firstNullifierInTx: Fr,
+    recipient: AztecAddress,
+  ) {
+    this.context = new MessageContext(txHash, uniqueNoteHashesInTx, firstNullifierInTx, recipient);
+  }
+
+  toFields(): Fr[] {
+    return [...serializeBoundedVec(this.log, PRIVATE_LOG_SIZE_IN_FIELDS), ...this.context.toFields()];
+  }
+}
+
+/**
+ * Helper function to serialize a bounded vector according to Noir's BoundedVec format
+ * @param values - The values to serialize
+ * @param maxLength - The maximum length of the bounded vector
+ * @returns The serialized bounded vector as Fr[]
+ */
+function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
+  const lengthDiff = maxLength - values.length;
+  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
+  const storage = values.concat(zeroPaddingArray);
+  return [...storage, new Fr(values.length)];
+}