@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/messaging/l1_to_l2_message_bundle.d.ts

@@ -0,0 +1,31 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+/**
+ * A block's L1-to-L2 message bundle: the real message leaves it inserts into the L1-to-L2 message tree and the count
+ * that drives both the compact (unpadded) tree append and the message-sponge absorb. See the Noir
+ * `L1ToL2MessageBundle`.
+ */
+export declare class L1ToL2MessageBundle {
+    /** The real message leaves in the leading lanes, padded with zeros to `MAX_L1_TO_L2_MSGS_PER_BLOCK`. Kept as a
+     * plain array (not a tuple) to avoid TS's deep-instantiation limit on the wide type. */
+    readonly messages: Fr[];
+    /** Number of real messages: drives both the compact tree append and the sponge absorb. */
+    readonly numMsgs: number;
+    constructor(
+    /** The real message leaves in the leading lanes, padded with zeros to `MAX_L1_TO_L2_MSGS_PER_BLOCK`. Kept as a
+     * plain array (not a tuple) to avoid TS's deep-instantiation limit on the wide type. */
+    messages: Fr[], 
+    /** Number of real messages: drives both the compact tree append and the sponge absorb. */
+    numMsgs: number);
+    /** An empty bundle: no leaves inserted, nothing absorbed. */
+    static empty(): L1ToL2MessageBundle;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    toString(): `0x${string}`;
+    static fromBuffer(buffer: Buffer | BufferReader): L1ToL2MessageBundle;
+    static fromString(str: string): L1ToL2MessageBundle;
+    toJSON(): Buffer<ArrayBufferLike>;
+    static get schema(): import("zod").ZodType<L1ToL2MessageBundle, string, import("zod/v4/core").$ZodTypeInternals<L1ToL2MessageBundle, string>>;
+}
+/** Wraps `messages` (the real leaves) into a bundle: the leaves fill the leading lanes, the count is the real count. */
+export declare function makeL1ToL2MessageBundle(messages: Fr[]): L1ToL2MessageBundle;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDFfdG9fbDJfbWVzc2FnZV9idW5kbGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZXNzYWdpbmcvbDFfdG9fbDJfbWVzc2FnZV9idW5kbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXpELE9BQU8sRUFBRSxZQUFZLEVBQXFCLE1BQU0sa0NBQWtDLENBQUM7QUFHbkY7Ozs7R0FJRztBQUNILHFCQUFhLG1CQUFtQjtJQUU1Qjs0RkFDd0Y7YUFDeEUsUUFBUSxFQUFFLEVBQUUsRUFBRTtJQUM5QiwwRkFBMEY7YUFDMUUsT0FBTyxFQUFFLE1BQU07SUFMakM7SUFDRTs0RkFDd0Y7SUFDeEUsUUFBUSxFQUFFLEVBQUUsRUFBRTtJQUM5QiwwRkFBMEY7SUFDMUUsT0FBTyxFQUFFLE1BQU0sRUFDN0I7SUFFSiw2REFBNkQ7SUFDN0QsTUFBTSxDQUFDLEtBQUssSUFBSSxtQkFBbUIsQ0FLbEM7SUFFRCxRQUFRLDRCQUVQO0lBRUQsUUFBUSxrQkFFUDtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxZQUFZLHVCQUs5QztJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsR0FBRyxFQUFFLE1BQU0sdUJBRTVCO0lBRUQsTUFBTSw0QkFFTDtJQUVELE1BQU0sS0FBSyxNQUFNLDZIQUVoQjtDQUNGO0FBRUQsd0hBQXdIO0FBQ3hILHdCQUFnQix1QkFBdUIsQ0FBQyxRQUFRLEVBQUUsRUFBRSxFQUFFLEdBQUcsbUJBQW1CLENBTTNFIn0=

package/dest/messaging/l1_to_l2_message_bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_to_l2_message_bundle.d.ts","sourceRoot":"","sources":["../../src/messaging/l1_to_l2_message_bundle.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AAGnF;;;;GAIG;AACH,qBAAa,mBAAmB;IAE5B;4FACwF;aACxE,QAAQ,EAAE,EAAE,EAAE;IAC9B,0FAA0F;aAC1E,OAAO,EAAE,MAAM;IALjC;IACE;4FACwF;IACxE,QAAQ,EAAE,EAAE,EAAE;IAC9B,0FAA0F;IAC1E,OAAO,EAAE,MAAM,EAC7B;IAEJ,6DAA6D;IAC7D,MAAM,CAAC,KAAK,IAAI,mBAAmB,CAKlC;IAED,QAAQ,4BAEP;IAED,QAAQ,kBAEP;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,uBAK9C;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,uBAE5B;IAED,MAAM,4BAEL;IAED,MAAM,KAAK,MAAM,6HAEhB;CACF;AAED,wHAAwH;AACxH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,EAAE,EAAE,GAAG,mBAAmB,CAM3E"}

package/dest/messaging/l1_to_l2_message_bundle.js

@@ -0,0 +1,51 @@
+import { MAX_L1_TO_L2_MSGS_PER_BLOCK } from '@aztec-labs/constants';
+import { padArrayEnd } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+/**
+ * A block's L1-to-L2 message bundle: the real message leaves it inserts into the L1-to-L2 message tree and the count
+ * that drives both the compact (unpadded) tree append and the message-sponge absorb. See the Noir
+ * `L1ToL2MessageBundle`.
+ */ export class L1ToL2MessageBundle {
+    messages;
+    numMsgs;
+    constructor(/** The real message leaves in the leading lanes, padded with zeros to `MAX_L1_TO_L2_MSGS_PER_BLOCK`. Kept as a
+     * plain array (not a tuple) to avoid TS's deep-instantiation limit on the wide type. */ messages, /** Number of real messages: drives both the compact tree append and the sponge absorb. */ numMsgs){
+        this.messages = messages;
+        this.numMsgs = numMsgs;
+    }
+    /** An empty bundle: no leaves inserted, nothing absorbed. */ static empty() {
+        return new L1ToL2MessageBundle(Array.from({
+            length: MAX_L1_TO_L2_MSGS_PER_BLOCK
+        }, ()=>Fr.ZERO), 0);
+    }
+    toBuffer() {
+        return serializeToBuffer(this.messages, this.numMsgs);
+    }
+    toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        // Array.from (not readArray with the literal cap) keeps the type `Fr[]` and avoids TS's deep-tuple instantiation.
+        const messages = Array.from({
+            length: MAX_L1_TO_L2_MSGS_PER_BLOCK
+        }, ()=>Fr.fromBuffer(reader));
+        return new L1ToL2MessageBundle(messages, reader.readNumber());
+    }
+    static fromString(str) {
+        return L1ToL2MessageBundle.fromBuffer(hexToBuffer(str));
+    }
+    toJSON() {
+        return this.toBuffer();
+    }
+    static get schema() {
+        return bufferSchemaFor(L1ToL2MessageBundle);
+    }
+}
+/** Wraps `messages` (the real leaves) into a bundle: the leaves fill the leading lanes, the count is the real count. */ export function makeL1ToL2MessageBundle(messages) {
+    // Explicit `<Fr, number>` keeps the result `Fr[]`; padding to the literal cap would otherwise infer a deep tuple.
+    return new L1ToL2MessageBundle(padArrayEnd(messages, Fr.ZERO, MAX_L1_TO_L2_MSGS_PER_BLOCK), messages.length);
+}

package/dest/messaging/l1_to_l2_message_source.d.ts

@@ -0,0 +1,61 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { L2Tips } from '../block/l2_block_source.js';
+import type { InboxBucket } from './inbox_bucket.js';
+/**
+ * Interface of classes allowing for the retrieval of L1 to L2 messages.
+ */
+export interface L1ToL2MessageSource {
+    /**
+     * Gets the L1 to L2 message index in the L1 to L2 message tree.
+     * @param l1ToL2Message - The L1 to L2 message.
+     * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
+     */
+    getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined>;
+    /**
+     * Returns the latest Inbox bucket opened at or before the given L1 timestamp, or undefined if no such bucket
+     * exists (i.e., every synced bucket was opened strictly after the timestamp). Used by the sequencer/validator
+     * to resolve the censorship cutoff and message-lag boundaries.
+     * @param timestamp - The L1 timestamp (in seconds) to look up at-or-before.
+     */
+    getLatestInboxBucketAtOrBefore(timestamp: bigint): Promise<InboxBucket | undefined>;
+    /**
+     * Returns the Inbox bucket with the given sequence number, or undefined if it has not been synced. Validators use
+     * this to resolve the bucket a proposal references and check its rolling hash.
+     * @param seq - The bucket sequence number.
+     */
+    getInboxBucket(seq: bigint): Promise<InboxBucket | undefined>;
+    /**
+     * Returns the Inbox bucket whose cumulative message total equals `totalMsgCount`, or undefined if no synced bucket
+     * sits on that boundary. A block's or checkpoint's L1-to-L2 tree leaf count equals the cumulative total of the last
+     * bucket it consumed (messages are indexed compactly, with no padding), so validators use this to resolve the
+     * bucket a block consumed through from the block's leaf count, without trusting a wire hint. `totalMsgCount === 0`
+     * resolves the genesis sentinel bucket (sequence 0); a total that does not land on a bucket boundary returns
+     * undefined.
+     * @param totalMsgCount - The cumulative Inbox message count (leaf count) to resolve to a bucket boundary.
+     */
+    getInboxBucketByTotalMsgCount(totalMsgCount: bigint): Promise<InboxBucket | undefined>;
+    /**
+     * Returns the message leaves absorbed into buckets in the range `(fromExclusive, toInclusive]`, in insertion
+     * order, for streaming message-bundle derivation. Both bounds must name buckets the source
+     * has synced; it throws otherwise, so that an empty result means the range holds no messages instead of hiding an
+     * unsynced bound. Callers that can tolerate an unsynced source resolve both bounds first, or map the failure to
+     * their own catch-up handling.
+     * @param fromExclusive - The lower bucket sequence bound, exclusive (0 means from the start of the Inbox).
+     * @param toInclusive - The upper bucket sequence bound, inclusive.
+     */
+    getL1ToL2MessagesBetweenBuckets(fromExclusive: bigint, toInclusive: bigint): Promise<Fr[]>;
+    /**
+     * Returns the message leaves in the cumulative Inbox message-count range `[startLeafCount, endLeafCount)`, in
+     * insertion order. The bounds are compact L1-to-L2 tree leaf counts, which every block header
+     * carries, so a consumer can ask for the messages a block or checkpoint consumed without resolving Inbox buckets
+     * itself. Both bounds must land on a bucket boundary the source has synced; it throws otherwise.
+     * @param startLeafCount - The cumulative Inbox message count the range starts at, inclusive.
+     * @param endLeafCount - The cumulative Inbox message count the range ends at, exclusive.
+     */
+    getL1ToL2MessagesBetweenLeafCounts(startLeafCount: bigint, endLeafCount: bigint): Promise<Fr[]>;
+    /**
+     * Returns the tips of the L2 chain.
+     */
+    getL2Tips(): Promise<L2Tips>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDFfdG9fbDJfbWVzc2FnZV9zb3VyY2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZXNzYWdpbmcvbDFfdG9fbDJfbWVzc2FnZV9zb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFFOUQsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFckQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsbUJBQW1CO0lBQ2xDOzs7O09BSUc7SUFDSCxxQkFBcUIsQ0FBQyxhQUFhLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBQUM7SUFFdEU7Ozs7O09BS0c7SUFDSCw4QkFBOEIsQ0FBQyxTQUFTLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxXQUFXLEdBQUcsU0FBUyxDQUFDLENBQUM7SUFFcEY7Ozs7T0FJRztJQUNILGNBQWMsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxXQUFXLEdBQUcsU0FBUyxDQUFDLENBQUM7SUFFOUQ7Ozs7Ozs7O09BUUc7SUFDSCw2QkFBNkIsQ0FBQyxhQUFhLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxXQUFXLEdBQUcsU0FBUyxDQUFDLENBQUM7SUFFdkY7Ozs7Ozs7O09BUUc7SUFDSCwrQkFBK0IsQ0FBQyxhQUFhLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFFM0Y7Ozs7Ozs7T0FPRztJQUNILGtDQUFrQyxDQUFDLGNBQWMsRUFBRSxNQUFNLEVBQUUsWUFBWSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUVoRzs7T0FFRztJQUNILFNBQVMsSUFBSSxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7Q0FDOUIifQ==

package/dest/messaging/l1_to_l2_message_source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_to_l2_message_source.d.ts","sourceRoot":"","sources":["../../src/messaging/l1_to_l2_message_source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,qBAAqB,CAAC,aAAa,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAEtE;;;;;OAKG;IACH,8BAA8B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;IAEpF;;;;OAIG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;IAE9D;;;;;;;;OAQG;IACH,6BAA6B,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;IAEvF;;;;;;;;OAQG;IACH,+BAA+B,CAAC,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;IAE3F;;;;;;;OAOG;IACH,kCAAkC,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;IAEhG;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAC9B"}

package/dest/messaging/l1_to_l2_message_source.js

@@ -0,0 +1,3 @@
+/**
+ * Interface of classes allowing for the retrieval of L1 to L2 messages.
+ */ export { };

package/dest/messaging/l1_to_l2_message_sponge.d.ts

@@ -0,0 +1,40 @@
+import { Poseidon2Sponge } from '@aztec-labs/blob-lib/types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+/**
+ * An absorb-only Poseidon2 sponge over L1-to-L2 message leaves.
+ *
+ * Mirrors `L1ToL2MessageSponge` in
+ * `noir-projects/fnd/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_sponge.nr`. Each block of a
+ * checkpoint absorbs its message bundle into the sponge it inherited from the previous block; the checkpoint root
+ * recomputes the sponge over the checkpoint's whole message list and asserts the accumulated states are equal.
+ */
+export declare class L1ToL2MessageSponge {
+    /** Sponge accumulating the absorbed message leaves. */
+    readonly sponge: Poseidon2Sponge;
+    /** Number of message leaves absorbed so far. */
+    numAbsorbed: number;
+    constructor(
+    /** Sponge accumulating the absorbed message leaves. */
+    sponge: Poseidon2Sponge, 
+    /** Number of message leaves absorbed so far. */
+    numAbsorbed: number);
+    /** A fresh, empty sponge (matching noir's `L1ToL2MessageSponge::new()` / `empty()`, i.e. `Poseidon2Sponge::new(0)`). */
+    static empty(): L1ToL2MessageSponge;
+    /** Absorb the given message leaves in order. */
+    absorb(leaves: Fr[]): Promise<void>;
+    clone(): L1ToL2MessageSponge;
+    static getFields(fields: FieldsOf<L1ToL2MessageSponge>): readonly [Poseidon2Sponge, number];
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static fromBuffer(buffer: Buffer | BufferReader): L1ToL2MessageSponge;
+    toFields(): Fr[];
+    static fromFields(fields: Fr[] | FieldReader): L1ToL2MessageSponge;
+}
+/**
+ * Accumulates a fresh message sponge over `leaves`, in order. This is the value the inbox parity proof commits to and
+ * the checkpoint's block roots reach, starting from the empty sponge. Every leaf passed in is absorbed, so any padding
+ * the caller includes is part of the accumulated state.
+ */
+export declare function accumulateL1ToL2MessageSponge(leaves: Fr[]): Promise<L1ToL2MessageSponge>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDFfdG9fbDJfbWVzc2FnZV9zcG9uZ2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZXNzYWdpbmcvbDFfdG9fbDJfbWVzc2FnZV9zcG9uZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQzdELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBd0MsTUFBTSxrQ0FBa0MsQ0FBQztBQUNuSCxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUU3RDs7Ozs7OztHQU9HO0FBQ0gscUJBQWEsbUJBQW1CO0lBRTVCLHVEQUF1RDthQUN2QyxNQUFNLEVBQUUsZUFBZTtJQUN2QyxnREFBZ0Q7SUFDekMsV0FBVyxFQUFFLE1BQU07SUFKNUI7SUFDRSx1REFBdUQ7SUFDdkMsTUFBTSxFQUFFLGVBQWU7SUFDdkMsZ0RBQWdEO0lBQ3pDLFdBQVcsRUFBRSxNQUFNLEVBQ3hCO0lBRUosd0hBQXdIO0lBQ3hILE1BQU0sQ0FBQyxLQUFLLElBQUksbUJBQW1CLENBRWxDO0lBRUQsZ0RBQWdEO0lBQzFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLGlCQUd4QjtJQUVELEtBQUssd0JBRUo7SUFFRCxNQUFNLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsbUJBQW1CLENBQUMsc0NBRXJEO0lBRUQsUUFBUSw0QkFFUDtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxZQUFZLEdBQUcsbUJBQW1CLENBR3BFO0lBRUQsUUFBUSxJQUFJLEVBQUUsRUFBRSxDQUVmO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxHQUFHLG1CQUFtQixDQUdqRTtDQUNGO0FBRUQ7Ozs7R0FJRztBQUNILHdCQUFzQiw2QkFBNkIsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBSTlGIn0=

package/dest/messaging/l1_to_l2_message_sponge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_to_l2_message_sponge.d.ts","sourceRoot":"","sources":["../../src/messaging/l1_to_l2_message_sponge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAwC,MAAM,kCAAkC,CAAC;AACnH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAE5B,uDAAuD;aACvC,MAAM,EAAE,eAAe;IACvC,gDAAgD;IACzC,WAAW,EAAE,MAAM;IAJ5B;IACE,uDAAuD;IACvC,MAAM,EAAE,eAAe;IACvC,gDAAgD;IACzC,WAAW,EAAE,MAAM,EACxB;IAEJ,wHAAwH;IACxH,MAAM,CAAC,KAAK,IAAI,mBAAmB,CAElC;IAED,gDAAgD;IAC1C,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,iBAGxB;IAED,KAAK,wBAEJ;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,mBAAmB,CAAC,sCAErD;IAED,QAAQ,4BAEP;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB,CAGpE;IAED,QAAQ,IAAI,EAAE,EAAE,CAEf;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,mBAAmB,CAGjE;CACF;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAI9F"}

package/dest/messaging/l1_to_l2_message_sponge.js

@@ -0,0 +1,56 @@
+import { Poseidon2Sponge } from '@aztec-labs/blob-lib/types';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec-labs/foundation/serialize';
+/**
+ * An absorb-only Poseidon2 sponge over L1-to-L2 message leaves.
+ *
+ * Mirrors `L1ToL2MessageSponge` in
+ * `noir-projects/fnd/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_sponge.nr`. Each block of a
+ * checkpoint absorbs its message bundle into the sponge it inherited from the previous block; the checkpoint root
+ * recomputes the sponge over the checkpoint's whole message list and asserts the accumulated states are equal.
+ */ export class L1ToL2MessageSponge {
+    sponge;
+    numAbsorbed;
+    constructor(/** Sponge accumulating the absorbed message leaves. */ sponge, /** Number of message leaves absorbed so far. */ numAbsorbed){
+        this.sponge = sponge;
+        this.numAbsorbed = numAbsorbed;
+    }
+    /** A fresh, empty sponge (matching noir's `L1ToL2MessageSponge::new()` / `empty()`, i.e. `Poseidon2Sponge::new(0)`). */ static empty() {
+        return new L1ToL2MessageSponge(Poseidon2Sponge.empty(), 0);
+    }
+    /** Absorb the given message leaves in order. */ async absorb(leaves) {
+        await this.sponge.absorb(leaves);
+        this.numAbsorbed += leaves.length;
+    }
+    clone() {
+        return L1ToL2MessageSponge.fromBuffer(this.toBuffer());
+    }
+    static getFields(fields) {
+        return [
+            fields.sponge,
+            fields.numAbsorbed
+        ];
+    }
+    toBuffer() {
+        return serializeToBuffer(...L1ToL2MessageSponge.getFields(this));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new L1ToL2MessageSponge(reader.readObject(Poseidon2Sponge), reader.readNumber());
+    }
+    toFields() {
+        return serializeToFields(...L1ToL2MessageSponge.getFields(this));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new L1ToL2MessageSponge(reader.readObject(Poseidon2Sponge), reader.readField().toNumber());
+    }
+}
+/**
+ * Accumulates a fresh message sponge over `leaves`, in order. This is the value the inbox parity proof commits to and
+ * the checkpoint's block roots reach, starting from the empty sponge. Every leaf passed in is absorbed, so any padding
+ * the caller includes is part of the accumulated state.
+ */ export async function accumulateL1ToL2MessageSponge(leaves) {
+    const sponge = L1ToL2MessageSponge.empty();
+    await sponge.absorb(leaves);
+    return sponge;
+}

package/dest/messaging/l2_actor.d.ts

@@ -0,0 +1,31 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import { AztecAddress } from '../aztec-address/index.js';
+/**
+ * The recipient of an L2 message.
+ */
+export declare class L2Actor {
+    /**
+     * The recipient of the message.
+     */
+    readonly recipient: AztecAddress;
+    /**
+     * The version of the protocol.
+     */
+    readonly version: number;
+    constructor(
+    /**
+     * The recipient of the message.
+     */
+    recipient: AztecAddress, 
+    /**
+     * The version of the protocol.
+     */
+    version: number);
+    static empty(): L2Actor;
+    toFields(): Fr[];
+    toBuffer(): Buffer;
+    static fromBuffer(buffer: Buffer | BufferReader): L2Actor;
+    static random(): Promise<L2Actor>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDJfYWN0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZXNzYWdpbmcvbDJfYWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ3pELE9BQU8sRUFBRSxZQUFZLEVBQXFCLE1BQU0sa0NBQWtDLENBQUM7QUFFbkYsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRXpEOztHQUVHO0FBQ0gscUJBQWEsT0FBTztJQUVoQjs7T0FFRzthQUNhLFNBQVMsRUFBRSxZQUFZO0lBQ3ZDOztPQUVHO2FBQ2EsT0FBTyxFQUFFLE1BQU07SUFSakM7SUFDRTs7T0FFRztJQUNhLFNBQVMsRUFBRSxZQUFZO0lBQ3ZDOztPQUVHO0lBQ2EsT0FBTyxFQUFFLE1BQU0sRUFDN0I7SUFFSixNQUFNLENBQUMsS0FBSyxZQUVYO0lBRUQsUUFBUSxJQUFJLEVBQUUsRUFBRSxDQUVmO0lBRUQsUUFBUSxJQUFJLE1BQU0sQ0FFakI7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLE9BQU8sQ0FLeEQ7SUFFRCxPQUFhLE1BQU0sSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLENBRXRDO0NBQ0YifQ==

package/dest/messaging/l2_actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l2_actor.d.ts","sourceRoot":"","sources":["../../src/messaging/l2_actor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AAEnF,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;GAEG;AACH,qBAAa,OAAO;IAEhB;;OAEG;aACa,SAAS,EAAE,YAAY;IACvC;;OAEG;aACa,OAAO,EAAE,MAAM;IARjC;IACE;;OAEG;IACa,SAAS,EAAE,YAAY;IACvC;;OAEG;IACa,OAAO,EAAE,MAAM,EAC7B;IAEJ,MAAM,CAAC,KAAK,YAEX;IAED,QAAQ,IAAI,EAAE,EAAE,CAEf;IAED,QAAQ,IAAI,MAAM,CAEjB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO,CAKxD;IAED,OAAa,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAEtC;CACF"}

package/dest/messaging/l2_actor.js

@@ -0,0 +1,39 @@
+import { randomInt } from '@aztec-labs/foundation/crypto/random';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { AztecAddress } from '../aztec-address/index.js';
+/**
+ * The recipient of an L2 message.
+ */ export class L2Actor {
+    recipient;
+    version;
+    constructor(/**
+     * The recipient of the message.
+     */ recipient, /**
+     * The version of the protocol.
+     */ version){
+        this.recipient = recipient;
+        this.version = version;
+    }
+    static empty() {
+        return new L2Actor(AztecAddress.ZERO, 0);
+    }
+    toFields() {
+        return [
+            this.recipient.toField(),
+            new Fr(BigInt(this.version))
+        ];
+    }
+    toBuffer() {
+        return serializeToBuffer(this.recipient, this.version);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const aztecAddr = AztecAddress.fromBuffer(reader);
+        const version = reader.readNumber();
+        return new L2Actor(aztecAddr, version);
+    }
+    static async random() {
+        return new L2Actor(await AztecAddress.random(), randomInt(1000));
+    }
+}

package/dest/messaging/l2_to_l1_membership.d.ts

@@ -0,0 +1,160 @@
+import { type EpochNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { SiblingPath } from '@aztec-labs/foundation/trees';
+import { z } from 'zod';
+import type { AztecNode } from '../interfaces/aztec-node.js';
+import { TxHash } from '../tx/tx_hash.js';
+import type { TxReceipt } from '../tx/tx_receipt.js';
+/**
+ * Provides access to the L1 Outbox's per-epoch roots so the witness helper can pick the smallest
+ * partial-proof root that covers a tx's checkpoint. Implemented by `OutboxContract` in the
+ * ethereum package.
+ */
+export interface OutboxRootsReader {
+    /**
+     * Returns the array of roots stored for `epoch`. Slot `i` holds the root inserted for
+     * `numCheckpointsInEpoch = i + 1`, or `Fr.ZERO` if no proof of that depth has landed yet. The
+     * returned array length is `MAX_CHECKPOINTS_PER_EPOCH`.
+     */
+    getRoots(epoch: EpochNumber): Promise<Fr[]>;
+}
+/**
+ * # L2-to-L1 Message Tree Structure and Leaf IDs
+ *
+ * ## Overview
+ * L2-to-L1 messages are organized in a hierarchical 4-level tree structure within each epoch:
+ *   Epoch → Checkpoints → Blocks → Transactions → Messages
+ *
+ * Each level uses an unbalanced Merkle tree, and some levels use compression (skipping zero hashes).
+ *
+ * ## Tree Levels
+ *
+ * 1. **Message Tree (TX Out Hash)**
+ *    - Leaves: Individual L2-to-L1 messages within a transaction
+ *    - Root: TX out hash
+ *    - Type: Unbalanced, non-compressed (the circuits ensure that all messages are not empty.)
+ *
+ * 2. **Block Tree**
+ *    - Leaves: TX out hashes from all transactions in a block
+ *    - Root: Block out hash
+ *    - Type: Unbalanced, compressed (zero hashes are skipped)
+ *    - Compression: If a tx has no messages (out hash = 0), that branch is ignored
+ *
+ * 3. **Checkpoint Tree**
+ *    - Leaves: Block out hashes from all blocks in a checkpoint
+ *    - Root: Checkpoint out hash
+ *    - Type: Unbalanced, compressed (zero hashes are skipped)
+ *    - Compression: If a block has no messages (out hash = 0), that branch is ignored
+ *
+ * 4. **Epoch Tree**
+ *    - Leaves: Checkpoint out hashes from all checkpoints in an epoch (padded to OUT_HASH_TREE_LEAF_COUNT)
+ *    - Root: Epoch out hash (set in the root rollup's public inputs and inserted into the Outbox on L1 when the epoch is proven)
+ *    - Type: Unbalanced, non-compressed
+ *    - **Important**: Padded with zeros up to OUT_HASH_TREE_LEAF_COUNT to allow for proofs of partial epochs
+ *
+ * ## Combined Membership Proof
+ * To prove a message exists in an epoch, we combine the sibling paths from all 4 trees:
+ *   [message siblings] + [tx siblings] + [block siblings] + [checkpoint siblings]
+ *
+ * ## Leaf ID: Stable Message Identification
+ *
+ * Each message gets a unique, stable **leaf ID** that identifies its position in the combined tree.
+ * The leaf ID is computed as:
+ *   leafId = 2^pathSize + leafIndex
+ *
+ * Where:
+ * - `pathSize`: Total length of the combined sibling path (from all 4 tree levels)
+ * - `leafIndex`: The message's index in a balanced tree representation at that height
+ *
+ * ### Why Leaf IDs Are Stable
+ *
+ * The leaf ID is based on the message's position in the tree structure, which is determined by:
+ * - The checkpoint index within the epoch
+ * - The block index within the checkpoint
+ * - The transaction index within the block
+ * - The message index within the transaction
+ *
+ * These indices are structural and do NOT depend on the total number of blocks/checkpoints in the epoch.
+ *
+ * ### Critical Property: Preserving Consumed Status
+ *
+ * **Problem**: On L1, epoch proofs can be submitted incrementally. For example:
+ * - First, a proof for checkpoints 1-10 of epoch 0 is submitted (proves the first 10 checkpoints)
+ * - Later, a proof for checkpoints 1-20 of epoch 0 is submitted (proves all 20 checkpoints)
+ *
+ * When the longer proof is submitted, it updates the epoch's out hash root on L1 to reflect the complete epoch (all 20
+ * checkpoints). However, some messages from checkpoints 1-10 may have already been consumed.
+ *
+ * **Solution**: The Outbox on L1 tracks consumed messages using a bitmap indexed by leaf ID.
+ * Because leaf IDs are stable (they don't change when more checkpoints are added to the epoch), messages that were consumed
+ * under the shorter proof remain marked as consumed under the longer proof.
+ *
+ * This prevents double-spending of L2-to-L1 messages when longer epoch proofs are submitted.
+ */
+/**
+ * Computes the unique leaf ID for an L2-to-L1 message.
+ *
+ * The leaf ID is stable across different epoch proof lengths and is used by the Outbox
+ * on L1 to track which messages have been consumed.
+ *
+ * @param membershipWitness - Contains the leafIndex and siblingPath for the message
+ * @returns The unique leaf ID used for tracking message consumption on L1
+ */
+export declare function getL2ToL1MessageLeafId(membershipWitness: Pick<L2ToL1MembershipWitness, 'leafIndex' | 'siblingPath'>): bigint;
+export type L2ToL1MembershipWitness = {
+    epochNumber: EpochNumber;
+    /**
+     * The number of checkpoints covered by the partial-proof root this witness was built against
+     * (1-indexed; equal to `roots-array-index + 1` on the Outbox). Pass this through to
+     * `Outbox.consume` so the contract reads the matching root slot.
+     */
+    numCheckpointsInEpoch: number;
+    root: Fr;
+    leafIndex: bigint;
+    siblingPath: SiblingPath<number>;
+};
+/**
+ * Zod schema for {@link L2ToL1MembershipWitness}. The sibling-path length varies with the shape of
+ * the per-epoch tree, so we use the unsized `SiblingPath.schema` here rather than a fixed-height
+ * `schemaFor`.
+ */
+export declare const L2ToL1MembershipWitnessSchema: z.ZodType<L2ToL1MembershipWitness, unknown, z.core.$ZodTypeInternals<L2ToL1MembershipWitness, unknown>>;
+/**
+ * Computes the L2 to L1 membership witness for a given message in a transaction.
+ *
+ * Queries the L1 Outbox to find the smallest partial-proof root that covers the tx's checkpoint,
+ * then builds the witness against that root by including only the first `numCheckpointsInEpoch`
+ * checkpoints of the epoch in the tree (the remaining slots are zero-padded, matching the shape
+ * the rollup proved). Returns `undefined` if the tx is not yet in a block/epoch or if the Outbox
+ * holds no root yet that covers the tx's checkpoint.
+ *
+ * @param node - The Aztec node to query for block/tx/epoch data.
+ * @param outboxOrRoots - Either an `OutboxRootsReader` (the helper will fetch the per-epoch roots),
+ *   or an already-resolved roots array of length `MAX_CHECKPOINTS_PER_EPOCH`. Pass the array when
+ *   you already read the outbox (e.g. inside a tight loop that resolves witnesses for many
+ *   messages in the same epoch) to avoid redundant L1 reads.
+ * @param message - The L2 to L1 message hash to prove membership of.
+ * @param txHashOrReceipt - Either the tx hash, or the already-fetched `TxReceipt`. Passing the
+ *   receipt skips an internal `getTxReceipt` call.
+ * @param messageIndexInTx - Optional index of the message within the transaction's L2-to-L1 messages.
+ *   If not provided, the message is found by scanning the tx's messages (throws if duplicates exist).
+ */
+export declare function computeL2ToL1MembershipWitness(node: Pick<AztecNode, 'getL2ToL1Messages' | 'getTxReceipt' | 'getBlock' | 'getCheckpointsData'>, outboxOrRoots: OutboxRootsReader | Fr[], message: Fr, txHashOrReceipt: TxHash | Pick<TxReceipt, 'txHash' | 'epochNumber' | 'blockNumber' | 'txIndexInBlock'>, messageIndexInTx?: number): Promise<L2ToL1MembershipWitness | undefined>;
+/**
+ * Computes a membership witness for a message in the epoch's L2-to-L1 message tree, given explicit position indices.
+ *
+ * @param messagesInEpoch - All L2-to-L1 messages in the epoch, organized as checkpoints → blocks → txs → messages.
+ * @param message - The message hash to prove membership of.
+ * @param checkpointIndex - Index of the checkpoint within the epoch's message array.
+ * @param blockIndex - Index of the block within the checkpoint.
+ * @param txIndex - Index of the transaction within the block.
+ * @param messageIndexInTx - Optional index of the message within the transaction's messages.
+ *   If not provided, the message is found by scanning (throws if duplicates exist within the tx).
+ */
+/** @internal Exported for testing only. */
+export declare function computeL2ToL1MembershipWitnessFromMessagesInEpoch(messagesInEpoch: Fr[][][][], message: Fr, checkpointIndex: number, blockIndex: number, txIndex: number, messageIndexInTx?: number): {
+    root: Fr;
+    leafIndex: bigint;
+    siblingPath: SiblingPath<number>;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dest/messaging/l2_to_l1_membership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l2_to_l1_membership.d.ts","sourceRoot":"","sources":["../../src/messaging/l2_to_l1_membership.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,sCAAsC,CAAC;AAC3F,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,WAAW,EAA4D,MAAM,8BAA8B,CAAC;AACrH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;CAC7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,iBAAiB,EAAE,IAAI,CAAC,uBAAuB,EAAE,WAAW,GAAG,aAAa,CAAC,GAC5E,MAAM,CAER;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,WAAW,CAAC;IACzB;;;;OAIG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAC9B,IAAI,EAAE,EAAE,CAAC;IACT,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,yGAMS,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,mBAAmB,GAAG,cAAc,GAAG,UAAU,GAAG,oBAAoB,CAAC,EAC/F,aAAa,EAAE,iBAAiB,GAAG,EAAE,EAAE,EACvC,OAAO,EAAE,EAAE,EACX,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,GAAG,aAAa,GAAG,aAAa,GAAG,gBAAgB,CAAC,EACtG,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAgE9C;AAgBD;;;;;;;;;;GAUG;AACH,2CAA2C;AAC3C,wBAAgB,iDAAiD,CAC/D,eAAe,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAC3B,OAAO,EAAE,EAAE,EACX,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,gBAAgB,CAAC,EAAE,MAAM,GACxB;IAAE,IAAI,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,CAoEnE"}