@aztec/stdlib 1.0.0-nightly.20250708 → 1.0.0-staging.0

package/dest/kernel/private_validation_requests.js

@@ -1,19 +1,25 @@
 import { MAX_KEY_VALIDATION_REQUESTS_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_TX } from '@aztec/constants';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { makeTuple } from '@aztec/foundation/array';
+import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { inspect } from 'util';
 import { ScopedKeyValidationRequestAndGenerator } from '../kernel/hints/scoped_key_validation_request_and_generator.js';
-import { ClaimedLengthArray, ClaimedLengthArrayFromBuffer } from './claimed_length_array.js';
 import { ScopedReadRequest } from './hints/read_request.js';
+import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
 import { OptionalNumber } from './utils/optional_number.js';
 /**
  * Validation requests accumulated during the execution of the transaction.
  */ export class PrivateValidationRequests {
+    forRollup;
     noteHashReadRequests;
     nullifierReadRequests;
     scopedKeyValidationRequestsAndGenerators;
     splitCounter;
     constructor(/**
+     * Validation requests that cannot be fulfilled in the current context (private or public), and must be instead be
+     * forwarded to the rollup for it to take care of them.
+     */ forRollup, /**
      * All the read requests made in this transaction.
      */ noteHashReadRequests, /**
      * All the nullifier read requests made in this transaction.
@@ -24,27 +30,32 @@ import { OptionalNumber } from './utils/optional_number.js';
      * A revertible nullifier and a non-revertible note hash will not be squashed.
      * It should be the "final" minRevertibleSideEffectCounter of a tx.
      */ splitCounter){
+        this.forRollup = forRollup;
         this.noteHashReadRequests = noteHashReadRequests;
         this.nullifierReadRequests = nullifierReadRequests;
         this.scopedKeyValidationRequestsAndGenerators = scopedKeyValidationRequestsAndGenerators;
         this.splitCounter = splitCounter;
     }
     getSize() {
-        return this.noteHashReadRequests.getSize() + this.nullifierReadRequests.getSize() + this.scopedKeyValidationRequestsAndGenerators.getSize() + this.splitCounter.getSize();
+        return this.forRollup.getSize() + arraySerializedSizeOfNonEmpty(this.noteHashReadRequests) + arraySerializedSizeOfNonEmpty(this.nullifierReadRequests) + arraySerializedSizeOfNonEmpty(this.scopedKeyValidationRequestsAndGenerators) + this.splitCounter.getSize();
     }
     toBuffer() {
-        return serializeToBuffer(this.noteHashReadRequests, this.nullifierReadRequests, this.scopedKeyValidationRequestsAndGenerators, this.splitCounter);
+        return serializeToBuffer(this.forRollup, this.noteHashReadRequests, this.nullifierReadRequests, this.scopedKeyValidationRequestsAndGenerators, this.splitCounter);
     }
     toString() {
         return bufferToHex(this.toBuffer());
     }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new PrivateValidationRequests(reader.readObject(RollupValidationRequests), reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest), reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest), reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator), reader.readObject(OptionalNumber));
+    }
     /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer or reader to read from.
    * @returns Deserialized object.
    */ static fromBuffer(buffer) {
         const reader = BufferReader.asReader(buffer);
-        return new PrivateValidationRequests(reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX)), reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX)), reader.readObject(ClaimedLengthArrayFromBuffer(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX)), reader.readObject(OptionalNumber));
+        return new PrivateValidationRequests(reader.readObject(RollupValidationRequests), reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest), reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest), reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator), reader.readObject(OptionalNumber));
     }
     /**
    * Deserializes from a string, corresponding to a write in cpp.
@@ -54,13 +65,14 @@ import { OptionalNumber } from './utils/optional_number.js';
         return PrivateValidationRequests.fromBuffer(hexToBuffer(str));
     }
     static empty() {
-        return new PrivateValidationRequests(ClaimedLengthArray.empty(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX), ClaimedLengthArray.empty(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX), ClaimedLengthArray.empty(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX), OptionalNumber.empty());
+        return new PrivateValidationRequests(RollupValidationRequests.empty(), makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest.empty), makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest.empty), makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator.empty), OptionalNumber.empty());
     }
     [inspect.custom]() {
         return `PrivateValidationRequests {
-  noteHashReadRequests: ${inspect(this.noteHashReadRequests)},
-  nullifierReadRequests: ${inspect(this.nullifierReadRequests)},
-  scopedKeyValidationRequestsAndGenerators: ${inspect(this.scopedKeyValidationRequestsAndGenerators)},
+  forRollup: ${inspect(this.forRollup)},
+  noteHashReadRequests: [${this.noteHashReadRequests.filter((x)=>!x.isEmpty()).map((h)=>inspect(h)).join(', ')}],
+  nullifierReadRequests: [${this.nullifierReadRequests.filter((x)=>!x.isEmpty()).map((h)=>inspect(h)).join(', ')}],
+  scopedKeyValidationRequestsAndGenerators: [${this.scopedKeyValidationRequestsAndGenerators.filter((x)=>!x.isEmpty()).map((h)=>inspect(h)).join(', ')}],
   splitCounter: ${this.splitCounter.getSize()}
   `;
     }

package/dest/kernel/utils/order_and_comparison.d.ts

@@ -1,5 +1,8 @@
 import type { Tuple } from '@aztec/foundation/serialize';
 import type { IsEmpty, Ordered } from './interfaces.js';
 export declare function countAccumulatedItems<T extends IsEmpty>(arr: T[]): number;
+export declare function mergeAccumulatedData<T extends IsEmpty, N extends number>(arr0: Tuple<T, N>, arr1: Tuple<T, N>, length?: N): Tuple<T, N>;
 export declare function sortByCounter<T extends Ordered & IsEmpty, N extends number>(arr: Tuple<T, N>, ascending?: boolean): Tuple<T, N>;
+export declare function isEmptyArray<T extends IsEmpty>(arr: T[]): boolean;
+export declare function getNonEmptyItems<T extends IsEmpty>(arr: T[]): T[];
 //# sourceMappingURL=order_and_comparison.d.ts.map

package/dest/kernel/utils/order_and_comparison.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"order_and_comparison.d.ts","sourceRoot":"","sources":["../../../src/kernel/utils/order_and_comparison.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAKxD,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,UAUhE;AAuBD,wBAAgB,aAAa,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,EAAE,CAAC,SAAS,MAAM,EACzE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,SAAS,GAAE,OAAc,GACxB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAEb"}
+{"version":3,"file":"order_and_comparison.d.ts","sourceRoot":"","sources":["../../../src/kernel/utils/order_and_comparison.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAKxD,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,UAUhE;AAGD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,MAAM,EACtE,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACjB,MAAM,GAAE,CAAoB,GAC3B,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAUb;AAuBD,wBAAgB,aAAa,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,EAAE,CAAC,SAAS,MAAM,EACzE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,SAAS,GAAE,OAAc,GACxB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAEb;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OAAO,CAEjE;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAEjE"}

package/dest/kernel/utils/order_and_comparison.js

@@ -11,6 +11,19 @@ export function countAccumulatedItems(arr) {
         return num;
     }, 0);
 }
+// Merges two arrays of length N into an array of length N.
+export function mergeAccumulatedData(arr0, arr1, length = arr0.length) {
+    const numNonEmptyItems0 = countAccumulatedItems(arr0);
+    const numNonEmptyItems1 = countAccumulatedItems(arr1);
+    if (numNonEmptyItems0 + numNonEmptyItems1 > length) {
+        throw new Error('Combined non-empty items exceeded the maximum allowed.');
+    }
+    const arr = [
+        ...arr0
+    ];
+    arr1.slice(0, numNonEmptyItems1).forEach((item, i)=>arr[i + numNonEmptyItems0] = item);
+    return arr;
+}
 // Sort items by a provided compare function. All empty items are padded to the right.
 function genericSort(arr, compareFn, ascending = true) {
     return [
@@ -31,3 +44,9 @@ function compareByCounter(a, b) {
 export function sortByCounter(arr, ascending = true) {
     return genericSort(arr, compareByCounter, ascending);
 }
+export function isEmptyArray(arr) {
+    return arr.every((item)=>item.isEmpty());
+}
+export function getNonEmptyItems(arr) {
+    return arr.filter((item)=>!item.isEmpty());
+}

package/dest/messaging/l2_to_l1_message.d.ts

@@ -207,7 +207,5 @@ export declare class ScopedCountedL2ToL1Message {
     isEmpty(): boolean;
     static fromBuffer(buffer: Buffer | BufferReader): ScopedCountedL2ToL1Message;
     toBuffer(): Buffer;
-    static fromFields(fields: Fr[] | FieldReader): ScopedCountedL2ToL1Message;
-    toFields(): Fr[];
 }
 //# sourceMappingURL=l2_to_l1_message.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"l2_to_l1_message.d.ts","sourceRoot":"","sources":["../../src/messaging/l2_to_l1_message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAwC,MAAM,6BAA6B,CAAC;AAE9G,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,qBAAa,aAAa;IAEf,SAAS,EAAE,UAAU;IACrB,OAAO,EAAE,EAAE;gBADX,SAAS,EAAE,UAAU,EACrB,OAAO,EAAE,EAAE;IAGpB,MAAM,KAAK,MAAM;;;;;;;;;;;;OAOhB;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,IAAI,aAAa;IAI7B;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;IAIrC;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;OAGG;IACH,QAAQ,IAAI,EAAE,EAAE;IAIhB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,aAAa;IAK5D;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAK/D;;;OAGG;IACH,OAAO,IAAI,OAAO;IAIlB,KAAK,CAAC,eAAe,EAAE,YAAY,GAAG,mBAAmB;CAG1D;AAED,qBAAa,oBAAoB;IAEtB,OAAO,EAAE,aAAa;IACtB,OAAO,EAAE,MAAM;gBADf,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM;IAGxB,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,MAAM,CAAC,KAAK;IAIZ,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C,QAAQ,IAAI,EAAE,EAAE;CAGjB;AAED,qBAAa,mBAAmB;IAErB,OAAO,EAAE,aAAa;IACtB,eAAe,EAAE,YAAY;gBAD7B,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,YAAY;IAGtC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,MAAM,CAAC,KAAK;IAIZ,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C,QAAQ,IAAI,EAAE,EAAE;CAGjB;AAED,qBAAa,0BAA0B;IAE5B,KAAK,EAAE,oBAAoB;IAC3B,eAAe,EAAE,YAAY;gBAD7B,KAAK,EAAE,oBAAoB,EAC3B,eAAe,EAAE,YAAY;IAGtC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,MAAM,CAAC,KAAK;IAIZ,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C,QAAQ,IAAI,EAAE,EAAE;CAGjB"}
+{"version":3,"file":"l2_to_l1_message.d.ts","sourceRoot":"","sources":["../../src/messaging/l2_to_l1_message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAwC,MAAM,6BAA6B,CAAC;AAE9G,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,qBAAa,aAAa;IAEf,SAAS,EAAE,UAAU;IACrB,OAAO,EAAE,EAAE;gBADX,SAAS,EAAE,UAAU,EACrB,OAAO,EAAE,EAAE;IAGpB,MAAM,KAAK,MAAM;;;;;;;;;;;;OAOhB;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,IAAI,aAAa;IAI7B;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;IAIrC;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;OAGG;IACH,QAAQ,IAAI,EAAE,EAAE;IAIhB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,aAAa;IAK5D;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAK/D;;;OAGG;IACH,OAAO,IAAI,OAAO;IAIlB,KAAK,CAAC,eAAe,EAAE,YAAY,GAAG,mBAAmB;CAG1D;AAED,qBAAa,oBAAoB;IAEtB,OAAO,EAAE,aAAa;IACtB,OAAO,EAAE,MAAM;gBADf,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM;IAGxB,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,MAAM,CAAC,KAAK;IAIZ,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C,QAAQ,IAAI,EAAE,EAAE;CAGjB;AAED,qBAAa,mBAAmB;IAErB,OAAO,EAAE,aAAa;IACtB,eAAe,EAAE,YAAY;gBAD7B,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,YAAY;IAGtC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,MAAM,CAAC,KAAK;IAIZ,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C,QAAQ,IAAI,EAAE,EAAE;CAGjB;AAED,qBAAa,0BAA0B;IAE5B,KAAK,EAAE,oBAAoB;IAC3B,eAAe,EAAE,YAAY;gBAD7B,KAAK,EAAE,oBAAoB,EAC3B,eAAe,EAAE,YAAY;IAGtC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,MAAM,CAAC,KAAK;IAIZ,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C,QAAQ,IAAI,MAAM;CAGnB"}

package/dest/messaging/l2_to_l1_message.js

@@ -165,11 +165,4 @@ export class ScopedCountedL2ToL1Message {
     toBuffer() {
         return serializeToBuffer(this.inner, this.contractAddress);
     }
-    static fromFields(fields) {
-        const reader = FieldReader.asReader(fields);
-        return new ScopedCountedL2ToL1Message(reader.readObject(CountedL2ToL1Message), reader.readObject(AztecAddress));
-    }
-    toFields() {
-        return serializeToFields(this.inner, this.contractAddress);
-    }
 }

package/dest/p2p/block_proposal.d.ts

@@ -3,8 +3,6 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
-import type { BlockInfo } from '../block/l2_block.js';
-import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
 import type { UInt32 } from '../types/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
@@ -29,8 +27,6 @@ export declare class BlockProposal extends Gossipable {
     readonly payload: ConsensusPayload;
     /** The signer of the BlockProposal over the header of the new block*/
     readonly signature: Signature;
-    /** The sequence of transactions in the block */
-    readonly txHashes: TxHash[];
     /** The transactions in the block */
     readonly txs?: Tx[] | undefined;
     static p2pTopic: TopicType;
@@ -42,15 +38,12 @@ export declare class BlockProposal extends Gossipable {
     payload: ConsensusPayload, 
     /** The signer of the BlockProposal over the header of the new block*/
     signature: Signature, 
-    /** The sequence of transactions in the block */
-    txHashes: TxHash[], 
     /** The transactions in the block */
     txs?: Tx[] | undefined);
     generateP2PMessageIdentifier(): Promise<Buffer32>;
     get archive(): Fr;
     get slotNumber(): Fr;
-    toBlockInfo(): BlockInfo;
-    static createProposalFromSigner(blockNumber: UInt32, payload: ConsensusPayload, txHashes: TxHash[], txs: Tx[] | undefined, payloadSigner: (payload: Buffer32) => Promise<Signature>): Promise<BlockProposal>;
+    static createProposalFromSigner(blockNumber: UInt32, payload: ConsensusPayload, txs: Tx[] | undefined, payloadSigner: (payload: Buffer32) => Promise<Signature>): Promise<BlockProposal>;
     /**Get Sender
      * Lazily evaluate the sender of the proposal; result is cached
      */

package/dest/p2p/block_proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_proposal.d.ts","sourceRoot":"","sources":["../../src/p2p/block_proposal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAM7C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,qBAAa,iBAAkB,SAAQ,QAAQ;gBACjC,IAAI,EAAE,MAAM;CAGzB;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,UAAU;IAMzC,8BAA8B;aACd,WAAW,EAAE,MAAM;IAEnC,iEAAiE;aACjD,OAAO,EAAE,gBAAgB;IAEzC,sEAAsE;aACtD,SAAS,EAAE,SAAS;IAEpC,gDAAgD;aAChC,QAAQ,EAAE,MAAM,EAAE;IAGlC,oCAAoC;aACpB,GAAG,CAAC,EAAE,EAAE,EAAE;IAnB5B,OAAgB,QAAQ,YAA4B;IAEpD,OAAO,CAAC,MAAM,CAAyB;;IAGrC,8BAA8B;IACd,WAAW,EAAE,MAAM;IAEnC,iEAAiE;IACjD,OAAO,EAAE,gBAAgB;IAEzC,sEAAsE;IACtD,SAAS,EAAE,SAAS;IAEpC,gDAAgD;IAChC,QAAQ,EAAE,MAAM,EAAE;IAGlC,oCAAoC;IACpB,GAAG,CAAC,EAAE,EAAE,EAAE,YAAA;IAKnB,4BAA4B,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI1D,IAAI,OAAO,IAAI,EAAE,CAEhB;IAED,IAAI,UAAU,IAAI,EAAE,CAEnB;IAED,WAAW,IAAI,SAAS;WASX,wBAAwB,CACnC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,MAAM,EAAE,EAElB,GAAG,EAAE,EAAE,EAAE,GAAG,SAAS,EACrB,aAAa,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,SAAS,CAAC;IAQ1D;;OAEG;IACH,SAAS;IAUT,UAAU;IAIV,QAAQ,IAAI,MAAM;IASlB,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAgB5D,OAAO,IAAI,MAAM;CAUlB"}
+{"version":3,"file":"block_proposal.d.ts","sourceRoot":"","sources":["../../src/p2p/block_proposal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAM7C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,qBAAa,iBAAkB,SAAQ,QAAQ;gBACjC,IAAI,EAAE,MAAM;CAGzB;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,UAAU;IAMzC,8BAA8B;aACd,WAAW,EAAE,MAAM;IAEnC,iEAAiE;aACjD,OAAO,EAAE,gBAAgB;IAEzC,sEAAsE;aACtD,SAAS,EAAE,SAAS;IAGpC,oCAAoC;aACpB,GAAG,CAAC,EAAE,EAAE,EAAE;IAhB5B,OAAgB,QAAQ,YAA4B;IAEpD,OAAO,CAAC,MAAM,CAAyB;;IAGrC,8BAA8B;IACd,WAAW,EAAE,MAAM;IAEnC,iEAAiE;IACjD,OAAO,EAAE,gBAAgB;IAEzC,sEAAsE;IACtD,SAAS,EAAE,SAAS;IAGpC,oCAAoC;IACpB,GAAG,CAAC,EAAE,EAAE,EAAE,YAAA;IAKnB,4BAA4B,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI1D,IAAI,OAAO,IAAI,EAAE,CAEhB;IAED,IAAI,UAAU,IAAI,EAAE,CAEnB;WAEY,wBAAwB,CACnC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,gBAAgB,EAEzB,GAAG,EAAE,EAAE,EAAE,GAAG,SAAS,EACrB,aAAa,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,SAAS,CAAC;IAQ1D;;OAEG;IACH,SAAS;IAUT,UAAU;IAIV,QAAQ,IAAI,MAAM;IASlB,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAe5D,OAAO,IAAI,MAAM;CAQlB"}

package/dest/p2p/block_proposal.js

@@ -2,7 +2,6 @@ import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256, recoverAddress } from '@aztec/foundation/crypto';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
@@ -22,13 +21,12 @@ export class BlockProposalHash extends Buffer32 {
     blockNumber;
     payload;
     signature;
-    txHashes;
     txs;
     static p2pTopic = TopicType.block_proposal;
     sender;
-    constructor(/** The number of the block */ blockNumber, /** The payload of the message, and what the signature is over */ payload, /** The signer of the BlockProposal over the header of the new block*/ signature, /** The sequence of transactions in the block */ txHashes, // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
+    constructor(/** The number of the block */ blockNumber, /** The payload of the message, and what the signature is over */ payload, /** The signer of the BlockProposal over the header of the new block*/ signature, // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
     /** The transactions in the block */ txs){
-        super(), this.blockNumber = blockNumber, this.payload = payload, this.signature = signature, this.txHashes = txHashes, this.txs = txs;
+        super(), this.blockNumber = blockNumber, this.payload = payload, this.signature = signature, this.txs = txs;
     }
     generateP2PMessageIdentifier() {
         return Promise.resolve(new BlockProposalHash(keccak256(this.signature.toBuffer())));
@@ -39,19 +37,11 @@ export class BlockProposalHash extends Buffer32 {
     get slotNumber() {
         return this.payload.header.slotNumber;
     }
-    toBlockInfo() {
-        return {
-            blockNumber: this.blockNumber,
-            slotNumber: this.slotNumber.toNumber(),
-            archive: this.archive.toString(),
-            txCount: this.txHashes.length
-        };
-    }
-    static async createProposalFromSigner(blockNumber, payload, txHashes, // Note(md): Provided separately to tx hashes such that this function can be optional
+    static async createProposalFromSigner(blockNumber, payload, // Note(md): Provided separately to tx hashes such that this function can be optional
     txs, payloadSigner) {
         const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
         const sig = await payloadSigner(hashed);
-        return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
+        return new BlockProposal(blockNumber, payload, sig, txs);
     }
     /**Get Sender
    * Lazily evaluate the sender of the proposal; result is cached
@@ -70,9 +60,7 @@ export class BlockProposalHash extends Buffer32 {
         const buffer = [
             this.blockNumber,
             this.payload,
-            this.signature,
-            this.txHashes.length,
-            this.txHashes
+            this.signature
         ];
         if (this.txs) {
             buffer.push(this.txs.length);
@@ -85,14 +73,13 @@ export class BlockProposalHash extends Buffer32 {
         const blockNumber = reader.readNumber();
         const payload = reader.readObject(ConsensusPayload);
         const sig = reader.readObject(Signature);
-        const txHashes = reader.readArray(reader.readNumber(), TxHash);
         if (!reader.isEmpty()) {
             const txs = reader.readArray(reader.readNumber(), Tx);
-            return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
+            return new BlockProposal(blockNumber, payload, sig, txs);
         }
-        return new BlockProposal(blockNumber, payload, sig, txHashes);
+        return new BlockProposal(blockNumber, payload, sig);
     }
     getSize() {
-        return 4 /* blockNumber */  + this.payload.getSize() + this.signature.getSize() + 4 /* txHashes.length */  + this.txHashes.length * TxHash.SIZE + (this.txs ? 4 /* txs.length */  + this.txs.reduce((acc, tx)=>acc + tx.getSize(), 0) : 0);
+        return 4 /* blockNumber */  + this.payload.getSize() + this.signature.getSize() + (this.txs ? this.txs.reduce((acc, tx)=>acc + tx.getSize(), 0) : 0);
     }
 }

package/dest/p2p/consensus_payload.d.ts

@@ -3,7 +3,7 @@ import { BufferReader } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
 import type { L2Block } from '../block/l2_block.js';
-import { ProposedBlockHeader, StateReference } from '../tx/index.js';
+import { ProposedBlockHeader, StateReference, TxHash } from '../tx/index.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 export declare class ConsensusPayload implements Signable {
     /** The proposed block header the attestation is made over */
@@ -12,6 +12,8 @@ export declare class ConsensusPayload implements Signable {
     readonly archive: Fr;
     /** The state reference after the block is added */
     readonly stateReference: StateReference;
+    /** The sequence of transactions in the block */
+    readonly txHashes: TxHash[];
     private size;
     constructor(
     /** The proposed block header the attestation is made over */
@@ -19,7 +21,9 @@ export declare class ConsensusPayload implements Signable {
     /** The archive root after the block is added */
     archive: Fr, 
     /** The state reference after the block is added */
-    stateReference: StateReference);
+    stateReference: StateReference, 
+    /** The sequence of transactions in the block */
+    txHashes: TxHash[]);
     static get schema(): z.ZodEffects<z.ZodObject<{
         header: import("@aztec/foundation/schemas").ZodFor<ProposedBlockHeader>;
         archive: z.ZodType<Fr, any, string>;
@@ -150,10 +154,12 @@ export declare class ConsensusPayload implements Signable {
                 nextAvailableLeafIndex: string | number | bigint;
             };
         }>;
+        txHashes: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, Buffer<ArrayBuffer>, string>, TxHash, string>, "many">;
     }, "strip", z.ZodTypeAny, {
         archive: Fr;
         header: ProposedBlockHeader;
         stateReference: StateReference;
+        txHashes: TxHash[];
     }, {
         archive: string;
         stateReference: {
@@ -176,6 +182,7 @@ export declare class ConsensusPayload implements Signable {
                 nextAvailableLeafIndex: string | number | bigint;
             };
         };
+        txHashes: string[];
         header?: any;
     }>, ConsensusPayload, {
         archive: string;
@@ -199,9 +206,10 @@ export declare class ConsensusPayload implements Signable {
                 nextAvailableLeafIndex: string | number | bigint;
             };
         };
+        txHashes: string[];
         header?: any;
     }>;
-    static getFields(fields: FieldsOf<ConsensusPayload>): readonly [ProposedBlockHeader, Fr, StateReference];
+    static getFields(fields: FieldsOf<ConsensusPayload>): readonly [ProposedBlockHeader, Fr, StateReference, TxHash[]];
     getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer;
     toBuffer(): Buffer;
     static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload;

package/dest/p2p/consensus_payload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consensus_payload.d.ts","sourceRoot":"","sources":["../../src/p2p/consensus_payload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE/E,qBAAa,gBAAiB,YAAW,QAAQ;IAI7C,6DAA6D;aAC7C,MAAM,EAAE,mBAAmB;IAC3C,gDAAgD;aAChC,OAAO,EAAE,EAAE;IAC3B,mDAAmD;aACnC,cAAc,EAAE,cAAc;IARhD,OAAO,CAAC,IAAI,CAAqB;;IAG/B,6DAA6D;IAC7C,MAAM,EAAE,mBAAmB;IAC3C,gDAAgD;IAChC,OAAO,EAAE,EAAE;IAC3B,mDAAmD;IACnC,cAAc,EAAE,cAAc;IAGhD,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAQhB;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IAInD,gBAAgB,CAAC,eAAe,EAAE,wBAAwB,GAAG,MAAM;IAsBnE,QAAQ,IAAI,MAAM;IAMlB,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,gBAAgB;IAS/D,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,gBAAgB;IAIvE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB;IAIlD,MAAM,CAAC,KAAK,IAAI,gBAAgB;IAIhC;;;OAGG;IACH,OAAO,IAAI,MAAM;IASjB,QAAQ;CAGT"}
+{"version":3,"file":"consensus_payload.d.ts","sourceRoot":"","sources":["../../src/p2p/consensus_payload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE/E,qBAAa,gBAAiB,YAAW,QAAQ;IAI7C,6DAA6D;aAC7C,MAAM,EAAE,mBAAmB;IAC3C,gDAAgD;aAChC,OAAO,EAAE,EAAE;IAC3B,mDAAmD;aACnC,cAAc,EAAE,cAAc;IAC9C,gDAAgD;aAChC,QAAQ,EAAE,MAAM,EAAE;IAVpC,OAAO,CAAC,IAAI,CAAqB;;IAG/B,6DAA6D;IAC7C,MAAM,EAAE,mBAAmB;IAC3C,gDAAgD;IAChC,OAAO,EAAE,EAAE;IAC3B,mDAAmD;IACnC,cAAc,EAAE,cAAc;IAC9C,gDAAgD;IAChC,QAAQ,EAAE,MAAM,EAAE;IAGpC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAShB;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IAInD,gBAAgB,CAAC,eAAe,EAAE,wBAAwB,GAAG,MAAM;IAwBnE,QAAQ,IAAI,MAAM;IAYlB,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,gBAAgB;IAU/D,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,gBAAgB;IAIvE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB;IASlD,MAAM,CAAC,KAAK,IAAI,gBAAgB;IAIhC;;;OAGG;IACH,OAAO,IAAI,MAAM;IASjB,QAAQ;CAKT"}

package/dest/p2p/consensus_payload.js

@@ -4,29 +4,33 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
-import { ProposedBlockHeader, StateReference } from '../tx/index.js';
+import { ProposedBlockHeader, StateReference, TxHash } from '../tx/index.js';
 export class ConsensusPayload {
     header;
     archive;
     stateReference;
+    txHashes;
     size;
-    constructor(/** The proposed block header the attestation is made over */ header, /** The archive root after the block is added */ archive, /** The state reference after the block is added */ stateReference){
+    constructor(/** The proposed block header the attestation is made over */ header, /** The archive root after the block is added */ archive, /** The state reference after the block is added */ stateReference, /** The sequence of transactions in the block */ txHashes){
         this.header = header;
         this.archive = archive;
         this.stateReference = stateReference;
+        this.txHashes = txHashes;
     }
     static get schema() {
         return z.object({
             header: ProposedBlockHeader.schema,
             archive: schemas.Fr,
-            stateReference: StateReference.schema
-        }).transform((obj)=>new ConsensusPayload(obj.header, obj.archive, obj.stateReference));
+            stateReference: StateReference.schema,
+            txHashes: z.array(TxHash.schema)
+        }).transform((obj)=>new ConsensusPayload(obj.header, obj.archive, obj.stateReference, obj.txHashes));
     }
     static getFields(fields) {
         return [
             fields.header,
             fields.archive,
-            fields.stateReference
+            fields.stateReference,
+            fields.txHashes
         ];
     }
     getPayloadToSign(domainSeparator) {
@@ -34,11 +38,13 @@ export class ConsensusPayload {
         '(' + 'bytes32, ' + // archive
         '((bytes32,uint32),((bytes32,uint32),(bytes32,uint32),(bytes32,uint32))), ' + // stateReference
         '(int256), ' + // oracleInput
-        'bytes32' + // headerHash
+        'bytes32, ' + // headerHash
+        'bytes32[]' + // txHashes
         ')');
         const archiveRoot = this.archive.toString();
         const stateReference = this.stateReference.toAbi();
         const headerHash = this.header.hash().toString();
+        const txArray = this.txHashes.map((tx)=>tx.toString());
         const encodedData = encodeAbiParameters(abi, [
             domainSeparator,
             [
@@ -47,7 +53,8 @@ export class ConsensusPayload {
                 [
                     0n
                 ],
-                headerHash
+                headerHash,
+                txArray
             ]
         ]);
         return hexToBuffer(encodedData);
@@ -56,23 +63,25 @@ export class ConsensusPayload {
         const buffer = serializeToBuffer([
             this.header,
             this.archive,
-            this.stateReference
+            this.stateReference,
+            this.txHashes.length,
+            this.txHashes
         ]);
         this.size = buffer.length;
         return buffer;
     }
     static fromBuffer(buf) {
         const reader = BufferReader.asReader(buf);
-        return new ConsensusPayload(reader.readObject(ProposedBlockHeader), reader.readObject(Fr), reader.readObject(StateReference));
+        return new ConsensusPayload(reader.readObject(ProposedBlockHeader), reader.readObject(Fr), reader.readObject(StateReference), reader.readArray(reader.readNumber(), TxHash));
     }
     static fromFields(fields) {
-        return new ConsensusPayload(fields.header, fields.archive, fields.stateReference);
+        return new ConsensusPayload(fields.header, fields.archive, fields.stateReference, fields.txHashes);
     }
     static fromBlock(block) {
-        return new ConsensusPayload(block.header.toPropose(), block.archive.root, block.header.state);
+        return new ConsensusPayload(block.header.toPropose(), block.archive.root, block.header.state, block.body.txEffects.map((tx)=>tx.txHash));
     }
     static empty() {
-        return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty());
+        return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty(), []);
     }
     /**
    * Get the size of the consensus payload in bytes.
@@ -86,6 +95,6 @@ export class ConsensusPayload {
         return this.size;
     }
     toString() {
-        return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
+        return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}, txHashes: ${this.txHashes.join(', ')}`;
     }
 }

package/dest/p2p/topic_type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"topic_type.d.ts","sourceRoot":"","sources":["../../src/p2p/topic_type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,UAE9E;AAED;;GAEG;AACH,oBAAY,SAAS;IACnB,EAAE,OAAO;IACT,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;CACxC;AAED,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,aAAa,eASlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,MAAM,uBAO9D"}
+{"version":3,"file":"topic_type.d.ts","sourceRoot":"","sources":["../../src/p2p/topic_type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,UAE9E;AAED;;GAEG;AACH,oBAAY,SAAS;IACnB,EAAE,OAAO;IACT,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;CACxC;AAED,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,aAAa,eAOlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,MAAM,uBAO9D"}

package/dest/p2p/topic_type.js

@@ -23,12 +23,10 @@ export function getTopicTypeForClientType(clientType) {
             "tx",
             "block_proposal"
         ];
-    } else {
-        const _ = clientType;
-        return [
-            "tx"
-        ];
     }
+    return [
+        "tx"
+    ];
 }
 /**
  * Convert the topic string into a set of labels

package/dest/proofs/proving_request_type.d.ts

@@ -4,14 +4,13 @@ export declare enum ProvingRequestType {
     PUBLIC_BASE_ROLLUP = 2,
     MERGE_ROLLUP = 3,
     EMPTY_BLOCK_ROOT_ROLLUP = 4,
-    PADDING_BLOCK_ROOT_ROLLUP = 5,
-    BLOCK_ROOT_ROLLUP = 6,
-    SINGLE_TX_BLOCK_ROOT_ROLLUP = 7,
-    BLOCK_MERGE_ROLLUP = 8,
-    ROOT_ROLLUP = 9,
-    BASE_PARITY = 10,
-    ROOT_PARITY = 11,
+    BLOCK_ROOT_ROLLUP = 5,
+    SINGLE_TX_BLOCK_ROOT_ROLLUP = 6,
+    BLOCK_MERGE_ROLLUP = 7,
+    ROOT_ROLLUP = 8,
+    BASE_PARITY = 9,
+    ROOT_PARITY = 10,
     /** Recursive Client IVC verification to connect private to public or rollup */
-    TUBE_PROOF = 12
+    TUBE_PROOF = 11
 }
 //# sourceMappingURL=proving_request_type.d.ts.map

package/dest/proofs/proving_request_type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proving_request_type.d.ts","sourceRoot":"","sources":["../../src/proofs/proving_request_type.ts"],"names":[],"mappings":"AAAA,oBAAY,kBAAkB;IAC5B,SAAS,IAAA;IAET,mBAAmB,IAAA;IACnB,kBAAkB,IAAA;IAClB,YAAY,IAAA;IACZ,uBAAuB,IAAA;IACvB,yBAAyB,IAAA;IACzB,iBAAiB,IAAA;IACjB,2BAA2B,IAAA;IAC3B,kBAAkB,IAAA;IAClB,WAAW,IAAA;IAEX,WAAW,KAAA;IACX,WAAW,KAAA;IACX,+EAA+E;IAC/E,UAAU,KAAA;CACX"}
+{"version":3,"file":"proving_request_type.d.ts","sourceRoot":"","sources":["../../src/proofs/proving_request_type.ts"],"names":[],"mappings":"AAAA,oBAAY,kBAAkB;IAC5B,SAAS,IAAA;IAET,mBAAmB,IAAA;IACnB,kBAAkB,IAAA;IAClB,YAAY,IAAA;IACZ,uBAAuB,IAAA;IACvB,iBAAiB,IAAA;IACjB,2BAA2B,IAAA;IAC3B,kBAAkB,IAAA;IAClB,WAAW,IAAA;IAEX,WAAW,IAAA;IACX,WAAW,KAAA;IACX,+EAA+E;IAC/E,UAAU,KAAA;CACX"}

package/dest/proofs/proving_request_type.js

@@ -4,13 +4,12 @@ export var ProvingRequestType = /*#__PURE__*/ function(ProvingRequestType) {
     ProvingRequestType[ProvingRequestType["PUBLIC_BASE_ROLLUP"] = 2] = "PUBLIC_BASE_ROLLUP";
     ProvingRequestType[ProvingRequestType["MERGE_ROLLUP"] = 3] = "MERGE_ROLLUP";
     ProvingRequestType[ProvingRequestType["EMPTY_BLOCK_ROOT_ROLLUP"] = 4] = "EMPTY_BLOCK_ROOT_ROLLUP";
-    ProvingRequestType[ProvingRequestType["PADDING_BLOCK_ROOT_ROLLUP"] = 5] = "PADDING_BLOCK_ROOT_ROLLUP";
-    ProvingRequestType[ProvingRequestType["BLOCK_ROOT_ROLLUP"] = 6] = "BLOCK_ROOT_ROLLUP";
-    ProvingRequestType[ProvingRequestType["SINGLE_TX_BLOCK_ROOT_ROLLUP"] = 7] = "SINGLE_TX_BLOCK_ROOT_ROLLUP";
-    ProvingRequestType[ProvingRequestType["BLOCK_MERGE_ROLLUP"] = 8] = "BLOCK_MERGE_ROLLUP";
-    ProvingRequestType[ProvingRequestType["ROOT_ROLLUP"] = 9] = "ROOT_ROLLUP";
-    ProvingRequestType[ProvingRequestType["BASE_PARITY"] = 10] = "BASE_PARITY";
-    ProvingRequestType[ProvingRequestType["ROOT_PARITY"] = 11] = "ROOT_PARITY";
-    /** Recursive Client IVC verification to connect private to public or rollup */ ProvingRequestType[ProvingRequestType["TUBE_PROOF"] = 12] = "TUBE_PROOF";
+    ProvingRequestType[ProvingRequestType["BLOCK_ROOT_ROLLUP"] = 5] = "BLOCK_ROOT_ROLLUP";
+    ProvingRequestType[ProvingRequestType["SINGLE_TX_BLOCK_ROOT_ROLLUP"] = 6] = "SINGLE_TX_BLOCK_ROOT_ROLLUP";
+    ProvingRequestType[ProvingRequestType["BLOCK_MERGE_ROLLUP"] = 7] = "BLOCK_MERGE_ROLLUP";
+    ProvingRequestType[ProvingRequestType["ROOT_ROLLUP"] = 8] = "ROOT_ROLLUP";
+    ProvingRequestType[ProvingRequestType["BASE_PARITY"] = 9] = "BASE_PARITY";
+    ProvingRequestType[ProvingRequestType["ROOT_PARITY"] = 10] = "ROOT_PARITY";
+    /** Recursive Client IVC verification to connect private to public or rollup */ ProvingRequestType[ProvingRequestType["TUBE_PROOF"] = 11] = "TUBE_PROOF";
     return ProvingRequestType;
 }({});

package/dest/rollup/base_or_merge_rollup_public_inputs.d.ts

@@ -2,11 +2,16 @@ import { SpongeBlob } from '@aztec/blob-lib';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
+import { RollupTypes } from '../types/shared.js';
 import { BlockConstantData } from './block_constant_data.js';
 /**
  * Output of the base and merge rollup circuits.
  */
 export declare class BaseOrMergeRollupPublicInputs {
+    /**
+     * Specifies from which type of rollup circuit these inputs are from.
+     */
+    rollupType: RollupTypes;
     /**
      * Number of txs in this rollup.
      */
@@ -45,6 +50,10 @@ export declare class BaseOrMergeRollupPublicInputs {
      */
     accumulatedManaUsed: Fr;
     constructor(
+    /**
+     * Specifies from which type of rollup circuit these inputs are from.
+     */
+    rollupType: RollupTypes, 
     /**
      * Number of txs in this rollup.
      */

package/dest/rollup/base_or_merge_rollup_public_inputs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base_or_merge_rollup_public_inputs.d.ts","sourceRoot":"","sources":["../../src/rollup/base_or_merge_rollup_public_inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;GAEG;AACH,qBAAa,6BAA6B;IAEtC;;OAEG;IACI,MAAM,EAAE,MAAM;IACrB;;OAEG;IACI,SAAS,EAAE,iBAAiB;IACnC;;OAEG;IACI,KAAK,EAAE,qBAAqB;IACnC;;OAEG;IACI,GAAG,EAAE,qBAAqB;IACjC;;OAEG;IACI,eAAe,EAAE,UAAU;IAClC;;OAEG;IACI,aAAa,EAAE,UAAU;IAChC;;;OAGG;IACI,OAAO,EAAE,EAAE;IAClB;;OAEG;IACI,eAAe,EAAE,EAAE;IAC1B;;OAEG;IACI,mBAAmB,EAAE,EAAE;;IApC9B;;OAEG;IACI,MAAM,EAAE,MAAM;IACrB;;OAEG;IACI,SAAS,EAAE,iBAAiB;IACnC;;OAEG;IACI,KAAK,EAAE,qBAAqB;IACnC;;OAEG;IACI,GAAG,EAAE,qBAAqB;IACjC;;OAEG;IACI,eAAe,EAAE,UAAU;IAClC;;OAEG;IACI,aAAa,EAAE,UAAU;IAChC;;;OAGG;IACI,OAAO,EAAE,EAAE;IAClB;;OAEG;IACI,eAAe,EAAE,EAAE;IAC1B;;OAEG;IACI,mBAAmB,EAAE,EAAE;IAGhC,iCAAiC;IACjC,MAAM,CAAC,KAAK;IAcZ;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,6BAA6B;IAe/E;;;OAGG;IACH,QAAQ;IAkBR;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM;IAI7B,8DAA8D;IAC9D,MAAM;IAIN,6CAA6C;IAC7C,MAAM,KAAK,MAAM,sEAEhB;CACF"}
+{"version":3,"file":"base_or_merge_rollup_public_inputs.d.ts","sourceRoot":"","sources":["../../src/rollup/base_or_merge_rollup_public_inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;GAEG;AACH,qBAAa,6BAA6B;IAEtC;;OAEG;IACI,UAAU,EAAE,WAAW;IAC9B;;OAEG;IACI,MAAM,EAAE,MAAM;IACrB;;OAEG;IACI,SAAS,EAAE,iBAAiB;IACnC;;OAEG;IACI,KAAK,EAAE,qBAAqB;IACnC;;OAEG;IACI,GAAG,EAAE,qBAAqB;IACjC;;OAEG;IACI,eAAe,EAAE,UAAU;IAClC;;OAEG;IACI,aAAa,EAAE,UAAU;IAChC;;;OAGG;IACI,OAAO,EAAE,EAAE;IAClB;;OAEG;IACI,eAAe,EAAE,EAAE;IAC1B;;OAEG;IACI,mBAAmB,EAAE,EAAE;;IAxC9B;;OAEG;IACI,UAAU,EAAE,WAAW;IAC9B;;OAEG;IACI,MAAM,EAAE,MAAM;IACrB;;OAEG;IACI,SAAS,EAAE,iBAAiB;IACnC;;OAEG;IACI,KAAK,EAAE,qBAAqB;IACnC;;OAEG;IACI,GAAG,EAAE,qBAAqB;IACjC;;OAEG;IACI,eAAe,EAAE,UAAU;IAClC;;OAEG;IACI,aAAa,EAAE,UAAU;IAChC;;;OAGG;IACI,OAAO,EAAE,EAAE;IAClB;;OAEG;IACI,eAAe,EAAE,EAAE;IAC1B;;OAEG;IACI,mBAAmB,EAAE,EAAE;IAGhC,iCAAiC;IACjC,MAAM,CAAC,KAAK;IAeZ;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,6BAA6B;IAgB/E;;;OAGG;IACH,QAAQ;IAmBR;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM;IAI7B,8DAA8D;IAC9D,MAAM;IAIN,6CAA6C;IAC7C,MAAM,KAAK,MAAM,sEAEhB;CACF"}

package/dest/rollup/base_or_merge_rollup_public_inputs.js

@@ -4,10 +4,12 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
+import { RollupTypes } from '../types/shared.js';
 import { BlockConstantData } from './block_constant_data.js';
 /**
  * Output of the base and merge rollup circuits.
  */ export class BaseOrMergeRollupPublicInputs {
+    rollupType;
     numTxs;
     constants;
     start;
@@ -18,6 +20,8 @@ import { BlockConstantData } from './block_constant_data.js';
     accumulatedFees;
     accumulatedManaUsed;
     constructor(/**
+     * Specifies from which type of rollup circuit these inputs are from.
+     */ rollupType, /**
      * Number of txs in this rollup.
      */ numTxs, /**
      * Data which is forwarded through the rollup circuits unchanged.
@@ -37,6 +41,7 @@ import { BlockConstantData } from './block_constant_data.js';
      */ accumulatedFees, /**
      * The summed `mana_used` of the constituent transactions.
      */ accumulatedManaUsed){
+        this.rollupType = rollupType;
         this.numTxs = numTxs;
         this.constants = constants;
         this.start = start;
@@ -48,7 +53,7 @@ import { BlockConstantData } from './block_constant_data.js';
         this.accumulatedManaUsed = accumulatedManaUsed;
     }
     /** Returns an empty instance. */ static empty() {
-        return new BaseOrMergeRollupPublicInputs(0, BlockConstantData.empty(), PartialStateReference.empty(), PartialStateReference.empty(), SpongeBlob.empty(), SpongeBlob.empty(), Fr.zero(), Fr.zero(), Fr.zero());
+        return new BaseOrMergeRollupPublicInputs(RollupTypes.Base, 0, BlockConstantData.empty(), PartialStateReference.empty(), PartialStateReference.empty(), SpongeBlob.empty(), SpongeBlob.empty(), Fr.zero(), Fr.zero(), Fr.zero());
     }
     /**
    * Deserializes from a buffer or reader.
@@ -57,13 +62,13 @@ import { BlockConstantData } from './block_constant_data.js';
    * @returns The deserialized public inputs.
    */ static fromBuffer(buffer) {
         const reader = BufferReader.asReader(buffer);
-        return new BaseOrMergeRollupPublicInputs(reader.readNumber(), reader.readObject(BlockConstantData), reader.readObject(PartialStateReference), reader.readObject(PartialStateReference), reader.readObject(SpongeBlob), reader.readObject(SpongeBlob), Fr.fromBuffer(reader), Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+        return new BaseOrMergeRollupPublicInputs(reader.readNumber(), reader.readNumber(), reader.readObject(BlockConstantData), reader.readObject(PartialStateReference), reader.readObject(PartialStateReference), reader.readObject(SpongeBlob), reader.readObject(SpongeBlob), Fr.fromBuffer(reader), Fr.fromBuffer(reader), Fr.fromBuffer(reader));
     }
     /**
    * Serialize this as a buffer.
    * @returns The buffer.
    */ toBuffer() {
-        return serializeToBuffer(this.numTxs, this.constants, this.start, this.end, this.startSpongeBlob, this.endSpongeBlob, this.outHash, this.accumulatedFees, this.accumulatedManaUsed);
+        return serializeToBuffer(this.rollupType, this.numTxs, this.constants, this.start, this.end, this.startSpongeBlob, this.endSpongeBlob, this.outHash, this.accumulatedFees, this.accumulatedManaUsed);
     }
     /**
    * Serialize this as a hex string.