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

package/src/logs/private_log.ts

@@ -1,24 +1,62 @@
-import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
+import { PRIVATE_LOG_LENGTH, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
 export class PrivateLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PRIVATE_LOG_SIZE_IN_FIELDS;
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PRIVATE_LOG_LENGTH;
 
-  constructor(public fields: Tuple<Fr, typeof PRIVATE_LOG_SIZE_IN_FIELDS>) {}
+  constructor(
+    public fields: Tuple<Fr, typeof PRIVATE_LOG_SIZE_IN_FIELDS>,
+    // Named `emittedLength` instead of `length` to avoid being confused with fields.length.
+    public emittedLength: number,
+  ) {}
+
+  static from(fields: FieldsOf<PrivateLog>) {
+    return new PrivateLog(...PrivateLog.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateLog>) {
+    return [fields.fields, fields.emittedLength] as const;
+  }
 
   toFields(): Fr[] {
-    return this.fields;
+    return serializeToFields(...PrivateLog.getFields(this));
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new PrivateLog(reader.readFieldArray(PRIVATE_LOG_SIZE_IN_FIELDS));
+    return new PrivateLog(reader.readFieldArray(PRIVATE_LOG_SIZE_IN_FIELDS), reader.readU32());
+  }
+
+  getEmittedFields() {
+    return this.fields.slice(0, this.emittedLength);
+  }
+
+  getEmittedFieldsWithoutTag() {
+    return this.fields.slice(1, this.emittedLength);
+  }
+
+  toBlobFields(): Fr[] {
+    return [new Fr(this.emittedLength)].concat(this.getEmittedFields());
+  }
+
+  static fromBlobFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const emittedLength = reader.readU32();
+    const emittedFields = reader.readFieldArray(emittedLength);
+    return new PrivateLog(padArrayEnd(emittedFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS), emittedLength);
   }
 
   isEmpty() {
@@ -26,44 +64,42 @@ export class PrivateLog {
   }
 
   static empty() {
-    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.zero));
+    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer(this.fields);
+    return serializeToBuffer(this.fields, this.emittedLength);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr));
-  }
-
-  static random() {
-    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random));
+    return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr), reader.readNumber());
   }
 
-  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 length prefix.
-    return this.getEmittedFields().length;
-  }
-
-  getEmittedFields() {
-    const lastNonZeroIndex = this.fields.findLastIndex(f => !f.isZero());
-    return this.fields.slice(0, lastNonZeroIndex + 1);
+  static random(tag = Fr.random()) {
+    const fields = makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random);
+    fields[0] = tag;
+    return new PrivateLog(fields, PRIVATE_LOG_SIZE_IN_FIELDS);
   }
 
   static get schema() {
     return z
       .object({
         fields: z.array(schemas.Fr),
+        emittedLength: z.number(),
       })
-      .transform(({ fields }) => PrivateLog.fromFields(fields));
+      .strict()
+      .transform(({ fields, emittedLength }) => PrivateLog.fromFields(fields.concat(new Fr(emittedLength))));
+  }
+
+  equals(other: PrivateLog) {
+    return this.fields.every((field, i) => field.equals(other.fields[i])) && this.emittedLength === other.emittedLength;
   }
 
   [inspect.custom](): string {
     return `PrivateLog {
       fields: [${this.fields.map(x => inspect(x)).join(', ')}],
+      emittedLength: ${this.emittedLength},
     }`;
   }
 }

package/src/logs/public_log.ts

@@ -1,5 +1,6 @@
-import { PUBLIC_LOG_DATA_SIZE_IN_FIELDS, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { PUBLIC_LOG_LENGTH, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import {
@@ -16,29 +17,65 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 
 export class PublicLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_SIZE_IN_FIELDS;
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_LENGTH;
 
-  constructor(public contractAddress: AztecAddress, public log: Tuple<Fr, typeof PUBLIC_LOG_DATA_SIZE_IN_FIELDS>) {}
+  constructor(
+    public contractAddress: AztecAddress,
+    public fields: Tuple<Fr, typeof PUBLIC_LOG_SIZE_IN_FIELDS>,
+    public emittedLength: number,
+  ) {}
 
-  toFields(): Fr[] {
-    return serializeToFields(...PublicLog.getFields(this));
+  static from(fields: FieldsOf<PublicLog>) {
+    return new PublicLog(...PublicLog.getFields(fields));
   }
 
   static getFields(fields: FieldsOf<PublicLog>) {
-    return [fields.contractAddress, fields.log] as const;
+    return [fields.contractAddress, fields.fields, fields.emittedLength] as const;
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...PublicLog.getFields(this));
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new PublicLog(reader.readObject(AztecAddress), reader.readFieldArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS));
+    return new PublicLog(
+      reader.readObject(AztecAddress),
+      reader.readFieldArray(PUBLIC_LOG_SIZE_IN_FIELDS),
+      reader.readU32(),
+    );
+  }
+
+  getEmittedFields() {
+    return this.fields.slice(0, this.emittedLength);
+  }
+
+  getEmittedFieldsWithoutTag() {
+    return this.fields.slice(1, this.emittedLength);
+  }
+
+  toBlobFields(): Fr[] {
+    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+  }
+
+  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 PublicLog(
+      contractAddress,
+      padArrayEnd(emittedFields, Fr.ZERO, PUBLIC_LOG_SIZE_IN_FIELDS),
+      emittedLength,
+    );
   }
 
   isEmpty() {
-    return this.contractAddress.isZero() && this.log.every(f => f.isZero());
+    return this.contractAddress.isZero() && this.fields.every(f => f.isZero()) && this.emittedLength === 0;
   }
 
   static empty() {
-    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr.zero));
+    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
   }
 
   toBuffer(): Buffer {
@@ -47,49 +84,50 @@ export class PublicLog {
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PublicLog(reader.readObject(AztecAddress), reader.readArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr));
+    return new PublicLog(
+      reader.readObject(AztecAddress),
+      reader.readArray(PUBLIC_LOG_SIZE_IN_FIELDS, Fr),
+      reader.readNumber(),
+    );
   }
 
   static async random() {
-    return new PublicLog(await AztecAddress.random(), makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr.random));
-  }
-
-  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 length prefix.
-    return this.getEmittedFields().length;
-  }
-
-  getEmittedFields() {
-    const fields = this.toFields();
-    const lastNonZeroIndex = fields.findLastIndex(f => !f.isZero());
-    return fields.slice(0, lastNonZeroIndex + 1);
+    return new PublicLog(
+      await AztecAddress.random(),
+      makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.random),
+      PUBLIC_LOG_SIZE_IN_FIELDS,
+    );
   }
 
   equals(other: this) {
     return (
       this.contractAddress.equals(other.contractAddress) &&
-      this.log.reduce((acc, field, i) => acc && field.equals(other.log[i]), true)
+      this.fields.every((field, i) => field.equals(other.fields[i])) &&
+      this.emittedLength === other.emittedLength
     );
   }
 
   toHumanReadable(): string {
-    return `PublicLog: (contractAddress: ${this.contractAddress} log: ${this.log})`;
+    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields}) emittedLength: ${this.emittedLength}`;
   }
 
   static get schema(): ZodFor<PublicLog> {
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        log: z.array(schemas.Fr),
+        fields: z.array(schemas.Fr).refine(arr => arr.length === PUBLIC_LOG_SIZE_IN_FIELDS),
+        emittedLength: z.number(),
       })
-      .transform(({ contractAddress, log }) => PublicLog.fromFields([contractAddress.toField(), ...log]));
+      .transform(({ contractAddress, fields, emittedLength }) =>
+        PublicLog.fromFields([contractAddress.toField(), ...fields, new Fr(emittedLength)]),
+      );
   }
 
   [inspect.custom](): string {
     return `PublicLog {
       contractAddress: ${inspect(this.contractAddress)},
-      log: [${this.log.map(x => inspect(x)).join(', ')}],
+      fields: [${this.fields.map(x => inspect(x)).join(', ')}],
+      emittedLength: ${this.emittedLength},
     }`;
   }
 }

package/src/logs/{l1_payload/shared_secret_derivation.ts → shared_secret_derivation.ts}

@@ -1,8 +1,7 @@
 import { Grumpkin } from '@aztec/foundation/crypto';
 import type { GrumpkinScalar, Point } from '@aztec/foundation/fields';
 
-import type { AztecAddress } from '../../aztec-address/index.js';
-import type { PublicKey } from '../../keys/public_key.js';
+import type { PublicKey } from '../keys/public_key.js';
 
 /**
  * Derive an Elliptic Curve Diffie-Hellman (ECDH) Shared Secret.
@@ -13,6 +12,9 @@ import type { PublicKey } from '../../keys/public_key.js';
  * @param publicKey - The public key used to derive shared secret.
  * @returns A derived shared secret.
  * @throws If the publicKey is zero.
+ *
+ * TODO(#12656): This function is kept around because of the utilityGetSharedSecret oracle. Nuke this once returning
+ * the app-siloed secret.
  */
 export async function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {
   if (publicKey.isZero()) {
@@ -24,12 +26,3 @@ export async function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKe
   const sharedSecret = await curve.mul(publicKey, secretKey);
   return sharedSecret;
 }
-
-export async function deriveEcdhSharedSecretUsingAztecAddress(
-  secretKey: GrumpkinScalar,
-  address: AztecAddress,
-): Promise<Point> {
-  const addressPoint = await address.toAddressPoint();
-  const sharedSecret = await deriveEcdhSharedSecret(secretKey, addressPoint);
-  return sharedSecret;
-}

package/src/logs/tx_scoped_l2_log.ts

@@ -1,11 +1,12 @@
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { schemas } from '../schemas/schemas.js';
 import { TxHash } from '../tx/tx_hash.js';
+import { PrivateLog } from './private_log.js';
+import { PublicLog } from './public_log.js';
 
+// TODO(#14460): Split to private and public versions instead of having this weird mix.
 export class TxScopedL2Log {
   constructor(
     /*
@@ -18,66 +19,77 @@ export class TxScopedL2Log {
      */
     public dataStartIndexForTx: number,
     /*
-     * The block this log is included in
+     * The index of the log in the transaction. Note that public and private logs are in separate arrays in the tx
+     * effect and for this reason these indices are independent (a private and public log can have the same index).
      */
-    public blockNumber: number,
+    public logIndexInTx: number,
     /*
-     * Indicates if the log comes from the public logs stream (partial note)
+     * The block this log is included in
      */
-    public isFromPublic: boolean,
+    public blockNumber: number,
     /*
-     * The log data
+     * The log data as either a PrivateLog or PublicLog
      */
-    public logData: Buffer,
+    public log: PrivateLog | PublicLog,
   ) {}
 
+  get isFromPublic() {
+    return this.log instanceof PublicLog;
+  }
+
   static get schema() {
     return z
       .object({
         txHash: TxHash.schema,
         dataStartIndexForTx: z.number(),
+        logIndexInTx: z.number(),
         blockNumber: z.number(),
-        isFromPublic: z.boolean(),
-        logData: schemas.Buffer,
+        log: z.union([PrivateLog.schema, PublicLog.schema]),
       })
       .transform(
-        ({ txHash, dataStartIndexForTx, blockNumber, isFromPublic, logData }) =>
-          new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, isFromPublic, logData),
+        ({ txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log }) =>
+          new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log),
       );
   }
 
   toBuffer() {
+    const isFromPublic = this.log instanceof PublicLog;
     return Buffer.concat([
       this.txHash.toBuffer(),
       numToUInt32BE(this.dataStartIndexForTx),
+      numToUInt32BE(this.logIndexInTx),
       numToUInt32BE(this.blockNumber),
-      boolToBuffer(this.isFromPublic),
-      this.logData,
+      boolToBuffer(isFromPublic),
+      this.log.toBuffer(),
     ]);
   }
 
   static fromBuffer(buffer: Buffer) {
     const reader = BufferReader.asReader(buffer);
-    return new TxScopedL2Log(
-      reader.readObject(TxHash),
-      reader.readNumber(),
-      reader.readNumber(),
-      reader.readBoolean(),
-      reader.readToEnd(),
-    );
+    const txHash = reader.readObject(TxHash);
+    const dataStartIndexForTx = reader.readNumber();
+    const logIndexInTx = reader.readNumber();
+    const blockNumber = reader.readNumber();
+    const isFromPublic = reader.readBoolean();
+    const log = isFromPublic ? PublicLog.fromBuffer(reader) : PrivateLog.fromBuffer(reader);
+
+    return new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log);
   }
 
-  static random() {
-    return new TxScopedL2Log(TxHash.random(), 1, 1, false, Fr.random().toBuffer());
+  static async random(isFromPublic = Math.random() < 0.5) {
+    const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
+    return new TxScopedL2Log(TxHash.random(), 1, 1, 1, log);
   }
 
   equals(other: TxScopedL2Log) {
     return (
       this.txHash.equals(other.txHash) &&
       this.dataStartIndexForTx === other.dataStartIndexForTx &&
+      this.logIndexInTx === other.logIndexInTx &&
       this.blockNumber === other.blockNumber &&
-      this.isFromPublic === other.isFromPublic &&
-      this.logData.equals(other.logData)
+      ((this.log instanceof PublicLog && other.log instanceof PublicLog) ||
+        (this.log instanceof PrivateLog && other.log instanceof PrivateLog)) &&
+      this.log.equals(other.log as any)
     );
   }
 }

package/src/messaging/inbox_leaf.ts

@@ -22,7 +22,22 @@ export class InboxLeaf {
     return new InboxLeaf(index, leaf);
   }
 
-  static smallestIndexFromL2Block(l2block: bigint): bigint {
-    return (l2block - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  static smallestIndexFromL2Block(l2blockNumber: number): bigint {
+    return BigInt(l2blockNumber - INITIAL_L2_BLOCK_NUM) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  }
+
+  /**
+   * Returns the range of valid indices for a given L2 block.
+   * Start index is inclusive, end index is exclusive.
+   */
+  static indexRangeFromL2Block(l2blockNumber: number): [bigint, bigint] {
+    const start = this.smallestIndexFromL2Block(l2blockNumber);
+    const end = start + BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    return [start, end];
+  }
+
+  /** Returns the L2 block number for a given leaf index */
+  static l2BlockFromIndex(index: bigint): number {
+    return Number(index / BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)) + INITIAL_L2_BLOCK_NUM;
   }
 }

package/src/messaging/index.ts

@@ -4,3 +4,4 @@ export * from './l1_to_l2_message_source.js';
 export * from './l1_actor.js';
 export * from './l2_actor.js';
 export * from './l2_to_l1_message.js';
+export * from './l2_to_l1_membership.js';

package/src/messaging/l1_to_l2_message_source.ts

@@ -1,5 +1,7 @@
 import type { Fr } from '@aztec/foundation/fields';
 
+import type { L2Tips } from '../block/l2_block_source.js';
+
 /**
  * Interface of classes allowing for the retrieval of L1 to L2 messages.
  */
@@ -9,7 +11,7 @@ export interface L1ToL2MessageSource {
    * @param blockNumber - L2 block number to get messages for.
    * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
    */
-  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
+  getL1ToL2Messages(blockNumber: number): Promise<Fr[]>;
 
   /**
    * Gets the L1 to L2 message index in the L1 to L2 message tree.
@@ -23,4 +25,9 @@ export interface L1ToL2MessageSource {
    * @returns The number of the latest L2 block processed by the implementation.
    */
   getBlockNumber(): Promise<number>;
+
+  /**
+   * Returns the tips of the L2 chain.
+   */
+  getL2Tips(): Promise<L2Tips>;
 }

package/src/messaging/l2_to_l1_membership.ts

@@ -0,0 +1,104 @@
+import { Fr } from '@aztec/foundation/fields';
+import {
+  SiblingPath,
+  UnbalancedMerkleTreeCalculator,
+  computeUnbalancedMerkleTreeRoot,
+  findLeafLevelAndIndex,
+  getMaxUnbalancedTreeDepth,
+} from '@aztec/foundation/trees';
+
+async function createOutHashTree(messages: Fr[]) {
+  const messageSubtreeHeight = getMaxUnbalancedTreeDepth(messages.length);
+  const calculator = UnbalancedMerkleTreeCalculator.create(messageSubtreeHeight);
+  await calculator.appendLeaves(messages.map(msg => msg.toBuffer()));
+  return calculator;
+}
+
+export interface MessageRetrieval {
+  getL2ToL1Messages(l2BlockNumber: number): Promise<Fr[][] | undefined>;
+}
+
+export type L2ToL1MembershipWitness = {
+  root: Fr;
+  leafIndex: bigint;
+  siblingPath: SiblingPath<number>;
+};
+
+export async function computeL2ToL1MembershipWitness(
+  messageRetriever: MessageRetrieval,
+  l2BlockNumber: number,
+  message: Fr,
+): Promise<L2ToL1MembershipWitness | undefined> {
+  const messagesForAllTxs = await messageRetriever.getL2ToL1Messages(l2BlockNumber);
+  if (!messagesForAllTxs) {
+    return undefined;
+  }
+
+  return computeL2ToL1MembershipWitnessFromMessagesForAllTxs(messagesForAllTxs, message);
+}
+
+export async function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
+  messagesForAllTxs: Fr[][],
+  message: Fr,
+): Promise<L2ToL1MembershipWitness> {
+  // Find index of message in subtree and index of tx in a block.
+  let messageIndexInTx = -1;
+  const txIndex = messagesForAllTxs.findIndex(messages => {
+    messageIndexInTx = messages.findIndex(msg => msg.equals(message));
+    return messageIndexInTx !== -1;
+  });
+
+  if (txIndex === -1) {
+    throw new Error('The L2ToL1Message you are trying to prove inclusion of does not exist');
+  }
+
+  // Get the txOutHash and the sibling path of the message in the tx subtree.
+  const txMessages = messagesForAllTxs[txIndex];
+  const txOutHashTree = await createOutHashTree(txMessages);
+  const txOutHash = txOutHashTree.getRoot();
+  const messagePathInSubtree = await txOutHashTree.getSiblingPath(message);
+
+  // Calculate txOutHash for all txs.
+  const txSubtreeRoots = messagesForAllTxs.map((messages, i) => {
+    // For a tx with no messages, we have to set an out hash of 0 to match what the circuit does.
+    if (messages.length === 0) {
+      return Fr.ZERO;
+    }
+
+    if (i === txIndex) {
+      return Fr.fromBuffer(txOutHash);
+    }
+
+    const root = computeUnbalancedMerkleTreeRoot(messages.map(msg => msg.toBuffer()));
+    return Fr.fromBuffer(root);
+  });
+
+  // Construct the top tree.
+  // The leaves of this tree are the txOutHashes.
+  // The root of this tree is the out_hash calculated in the circuit.
+  const topTree = await createOutHashTree(txSubtreeRoots);
+  const root = Fr.fromBuffer(topTree.getRoot());
+
+  // Compute the combined sibling path by appending the tx subtree path to the top tree path.
+  const txPathInTopTree = await topTree.getSiblingPath(txOutHash);
+  const combinedPath = messagePathInSubtree.toBufferArray().concat(txPathInTopTree.toBufferArray());
+
+  // Compute the combined index.
+  // It is the index of the message in the balanced tree at its current height.
+  const txLeafPosition = findLeafLevelAndIndex(messagesForAllTxs.length, txIndex);
+  const messageLeafPosition = findLeafLevelAndIndex(txMessages.length, messageIndexInTx);
+  const numLeavesInLeftSubtrees = txLeafPosition.indexAtLevel * (1 << messageLeafPosition.level);
+  const combinedIndex = numLeavesInLeftSubtrees + messageLeafPosition.indexAtLevel;
+
+  return {
+    root,
+    leafIndex: BigInt(combinedIndex),
+    siblingPath: new SiblingPath(combinedPath.length, combinedPath),
+  };
+}
+
+export function getL2ToL1MessageLeafId(
+  membershipWitness: Pick<L2ToL1MembershipWitness, 'leafIndex' | 'siblingPath'>,
+): bigint {
+  return 2n ** BigInt(membershipWitness.siblingPath.pathSize) + membershipWitness.leafIndex;
+}