@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/p2p/consensus_payload.d.ts

@@ -1,51 +1,247 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
-import { BlockHeader } from '../tx/block_header.js';
-import { TxHash } from '../tx/tx_hash.js';
+import type { L2Block } from '../block/l2_block.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { StateReference } from '../tx/state_reference.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 export declare class ConsensusPayload implements Signable {
-    /** The block header the attestation is made over */
-    readonly header: BlockHeader;
+    /** The proposed block header the attestation is made over */
+    readonly header: CheckpointHeader;
+    /** The archive root after the block is added */
     readonly archive: Fr;
-    /** The sequence of transactions in the block */
-    readonly txHashes: TxHash[];
+    /** The state reference after the block is added */
+    readonly stateReference: StateReference;
     private size;
     constructor(
-    /** The block header the attestation is made over */
-    header: BlockHeader, archive: Fr, 
-    /** The sequence of transactions in the block */
-    txHashes: TxHash[]);
+    /** The proposed block header the attestation is made over */
+    header: CheckpointHeader, 
+    /** The archive root after the block is added */
+    archive: Fr, 
+    /** The state reference after the block is added */
+    stateReference: StateReference);
     static get schema(): z.ZodEffects<z.ZodObject<{
-        header: import("@aztec/foundation/schemas").ZodFor<BlockHeader>;
+        header: import("@aztec/foundation/schemas").ZodFor<CheckpointHeader>;
         archive: z.ZodType<Fr, any, string>;
-        txHashes: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, Buffer, string>, TxHash, string>, "many">;
+        stateReference: z.ZodEffects<z.ZodObject<{
+            l1ToL2MessageTree: z.ZodEffects<z.ZodObject<{
+                root: z.ZodType<Fr, any, string>;
+                nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                root: Fr;
+                nextAvailableLeafIndex: number;
+            }, {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            }>;
+            partial: z.ZodEffects<z.ZodObject<{
+                noteHashTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+                nullifierTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+                publicDataTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                noteHashTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                nullifierTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                publicDataTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+            }, {
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            }>, import("../tx/partial_state_reference.js").PartialStateReference, {
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            partial: import("../tx/partial_state_reference.js").PartialStateReference;
+            l1ToL2MessageTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+        }, {
+            partial: {
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            l1ToL2MessageTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+        }>, StateReference, {
+            partial: {
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            l1ToL2MessageTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+        }>;
     }, "strip", z.ZodTypeAny, {
-        header: BlockHeader;
         archive: Fr;
-        txHashes: TxHash[];
+        header: CheckpointHeader;
+        stateReference: StateReference;
     }, {
         archive: string;
-        txHashes: string[];
+        stateReference: {
+            partial: {
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            l1ToL2MessageTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+        };
         header?: any;
     }>, ConsensusPayload, {
         archive: string;
-        txHashes: string[];
+        stateReference: {
+            partial: {
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            l1ToL2MessageTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+        };
         header?: any;
     }>;
-    static getFields(fields: FieldsOf<ConsensusPayload>): readonly [BlockHeader, Fr, TxHash[]];
-    getPayloadToSign(domainSeparator: SignatureDomainSeparator): Promise<Buffer>;
+    static getFields(fields: FieldsOf<ConsensusPayload>): readonly [CheckpointHeader, Fr, StateReference];
+    getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer;
     toBuffer(): Buffer;
+    equals(other: ConsensusPayload): boolean;
     static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload;
     static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload;
+    static fromBlock(block: L2Block): ConsensusPayload;
     static empty(): ConsensusPayload;
+    static random(): ConsensusPayload;
     /**
      * Get the size of the consensus payload in bytes.
      * @returns The size of the consensus payload.
      */
     getSize(): number;
+    toInspect(): {
+        header: {
+            lastArchive: `0x${string}`;
+            contentCommitment: {
+                blobsHash: `0x${string}`;
+                inHash: `0x${string}`;
+                outHash: `0x${string}`;
+            };
+            slotNumber: bigint;
+            timestamp: bigint;
+            coinbase: `0x${string}`;
+            feeRecipient: `0x${string}`;
+            gasFees: {
+                feePerDaGas: bigint;
+                feePerL2Gas: bigint;
+            };
+            totalManaUsed: bigint;
+        };
+        archive: `0x${string}`;
+        stateReference: {
+            l1ToL2MessageTree: `0x${string}`;
+            noteHashTree: `0x${string}`;
+            nullifierTree: `0x${string}`;
+            publicDataTree: `0x${string}`;
+        };
+    };
+    toString(): string;
 }
 //# sourceMappingURL=consensus_payload.d.ts.map

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,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE/E,qBAAa,gBAAiB,YAAW,QAAQ;IAI7C,oDAAoD;aACpC,MAAM,EAAE,WAAW;aAEnB,OAAO,EAAE,EAAE;IAC3B,gDAAgD;aAChC,QAAQ,EAAE,MAAM,EAAE;IARpC,OAAO,CAAC,IAAI,CAAqB;;IAG/B,oDAAoD;IACpC,MAAM,EAAE,WAAW,EAEnB,OAAO,EAAE,EAAE;IAC3B,gDAAgD;IAChC,QAAQ,EAAE,MAAM,EAAE;IAGpC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;OAQhB;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IAI7C,gBAAgB,CAAC,eAAe,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC;IAiBlF,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,KAAK,IAAI,gBAAgB;IAIhC;;;OAGG;IACH,OAAO,IAAI,MAAM;CAQlB"}
+{"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,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE/E,qBAAa,gBAAiB,YAAW,QAAQ;IAI7C,6DAA6D;aAC7C,MAAM,EAAE,gBAAgB;IACxC,gDAAgD;aAChC,OAAO,EAAE,EAAE;IAC3B,mDAAmD;aACnC,cAAc,EAAE,cAAc;IARhD,OAAO,CAAC,IAAI,CAAqB;;IAG/B,6DAA6D;IAC7C,MAAM,EAAE,gBAAgB;IACxC,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;IAIX,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO;IAQ/C,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;IAIlD,MAAM,CAAC,KAAK,IAAI,gBAAgB;IAIhC,MAAM,CAAC,MAAM,IAAI,gBAAgB;IAIjC;;;OAGG;IACH,OAAO,IAAI,MAAM;IASjB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;IAQT,QAAQ;CAGT"}

package/dest/p2p/consensus_payload.js

@@ -4,69 +4,81 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
-import { BlockHeader } from '../tx/block_header.js';
-import { TxHash } from '../tx/tx_hash.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { StateReference } from '../tx/state_reference.js';
 export class ConsensusPayload {
     header;
     archive;
-    txHashes;
+    stateReference;
     size;
-    constructor(/** The block header the attestation is made over */ header, // TODO(https://github.com/AztecProtocol/aztec-packages/pull/7727#discussion_r1713670830): temporary
-    archive, /** The sequence of transactions in the block */ txHashes){
+    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){
         this.header = header;
         this.archive = archive;
-        this.txHashes = txHashes;
+        this.stateReference = stateReference;
     }
     static get schema() {
         return z.object({
-            header: BlockHeader.schema,
+            header: CheckpointHeader.schema,
             archive: schemas.Fr,
-            txHashes: z.array(TxHash.schema)
-        }).transform((obj)=>new ConsensusPayload(obj.header, obj.archive, obj.txHashes));
+            stateReference: StateReference.schema
+        }).transform((obj)=>new ConsensusPayload(obj.header, obj.archive, obj.stateReference));
     }
     static getFields(fields) {
         return [
             fields.header,
             fields.archive,
-            fields.txHashes
+            fields.stateReference
         ];
     }
-    async getPayloadToSign(domainSeparator) {
-        const abi = parseAbiParameters('uint8, (bytes32, bytes32, (uint256), bytes, bytes32[])');
-        const txArray = this.txHashes.map((tx)=>tx.toString());
+    getPayloadToSign(domainSeparator) {
+        const abi = parseAbiParameters('uint8, ' + //domainSeperator
+        '(' + 'bytes32, ' + // archive
+        '((bytes32,uint32),((bytes32,uint32),(bytes32,uint32),(bytes32,uint32))), ' + // stateReference
+        '(int256), ' + // oracleInput
+        'bytes32' + // headerHash
+        ')');
+        const archiveRoot = this.archive.toString();
+        const stateReference = this.stateReference.toAbi();
+        const headerHash = this.header.hash().toString();
         const encodedData = encodeAbiParameters(abi, [
             domainSeparator,
             [
-                this.archive.toString(),
-                (await this.header.hash()).toString(),
+                archiveRoot,
+                stateReference,
                 [
                     0n
                 ],
-                this.header.toString(),
-                txArray
+                headerHash
             ]
         ]);
         return hexToBuffer(encodedData);
     }
     toBuffer() {
-        const buffer = serializeToBuffer([
+        return serializeToBuffer([
             this.header,
             this.archive,
-            this.txHashes.length,
-            this.txHashes
+            this.stateReference
         ]);
-        this.size = buffer.length;
-        return buffer;
+    }
+    equals(other) {
+        return this.header.equals(other.header) && this.archive.equals(other.archive) && this.stateReference.equals(other.stateReference);
     }
     static fromBuffer(buf) {
         const reader = BufferReader.asReader(buf);
-        return new ConsensusPayload(reader.readObject(BlockHeader), reader.readObject(Fr), reader.readArray(reader.readNumber(), TxHash));
+        const payload = new ConsensusPayload(reader.readObject(CheckpointHeader), reader.readObject(Fr), reader.readObject(StateReference));
+        return payload;
     }
     static fromFields(fields) {
-        return new ConsensusPayload(fields.header, fields.archive, fields.txHashes);
+        return new ConsensusPayload(fields.header, fields.archive, fields.stateReference);
+    }
+    static fromBlock(block) {
+        return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root, block.header.state);
     }
     static empty() {
-        return new ConsensusPayload(BlockHeader.empty(), Fr.ZERO, []);
+        return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, StateReference.empty());
+    }
+    static random() {
+        return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), StateReference.random());
     }
     /**
    * Get the size of the consensus payload in bytes.
@@ -79,4 +91,14 @@ export class ConsensusPayload {
         this.size = this.toBuffer().length;
         return this.size;
     }
+    toInspect() {
+        return {
+            header: this.header.toInspect(),
+            archive: this.archive.toString(),
+            stateReference: this.stateReference.toInspect()
+        };
+    }
+    toString() {
+        return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
+    }
 }

package/dest/p2p/gossipable.d.ts

@@ -1,30 +1,31 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { Buffer32 } from '@aztec/foundation/buffer';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import type { TopicType } from './topic_type.js';
+export declare class P2PMessage {
+    readonly payload: Buffer;
+    constructor(payload: Buffer);
+    static fromGossipable(message: Gossipable): P2PMessage;
+    static fromMessageData(messageData: Buffer): P2PMessage;
+    toMessageData(): Buffer;
+}
 /**
  * Gossipable
  *
  * Any class which extends gossipable will be able to be Gossiped over the p2p network
  */
 export declare abstract class Gossipable {
-    /** p2p Topic
-     *
-     * - The p2p topic identifier, this determines how the message is handled
-     */
-    static p2pTopic: string;
-    /** p2p Message Identifier
-     *
-     *  - A digest of the message information, this key is used for deduplication
-     */
-    abstract p2pMessageIdentifier(): Promise<Buffer32>;
-    /** To Buffer
-     *
-     * - Serialization method
+    private cachedId;
+    /** The p2p topic identifier, this determines how the message is handled */
+    static p2pTopic: TopicType;
+    /**
+     * A digest of the message information **used for logging only**.
+     * The identifier used for deduplication is `getMsgIdFn` as defined in `encoding.ts` which is a hash over topic and data.
      */
+    p2pMessageIdentifier(): Promise<Buffer32>;
+    abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
     abstract toBuffer(): Buffer;
+    toMessage(): Buffer;
     /**
      * Get the size of the gossipable object.
-     *
      * This is used for metrics recording.
      */
     abstract getSize(): number;

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

@@ -1 +1 @@
-{"version":3,"file":"gossipable.d.ts","sourceRoot":"","sources":["../../src/p2p/gossipable.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;GAIG;AACH,8BAAsB,UAAU;IAC9B;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,oBAAoB,IAAI,OAAO,CAAC,QAAQ,CAAC;IAElD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,IAAI,MAAM;IAE3B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,IAAI,MAAM;CAC3B"}
+{"version":3,"file":"gossipable.d.ts","sourceRoot":"","sources":["../../src/p2p/gossipable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,qBAAa,UAAU;aACO,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;IAE3C,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU;IAItD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU;IAMvD,aAAa,IAAI,MAAM;CAGxB;AAED;;;;GAIG;AACH,8BAAsB,UAAU;IAC9B,OAAO,CAAC,QAAQ,CAAuB;IACvC,2EAA2E;IAC3E,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC;IAE3B;;;OAGG;IACG,oBAAoB,IAAI,OAAO,CAAC,QAAQ,CAAC;IAQ/C,QAAQ,CAAC,4BAA4B,IAAI,OAAO,CAAC,QAAQ,CAAC;IAE1D,QAAQ,CAAC,QAAQ,IAAI,MAAM;IAE3B,SAAS,IAAI,MAAM;IAInB;;;OAGG;IACH,QAAQ,CAAC,OAAO,IAAI,MAAM;CAC3B"}

package/dest/p2p/gossipable.js

@@ -1,10 +1,41 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+export class P2PMessage {
+    payload;
+    constructor(payload){
+        this.payload = payload;
+    }
+    static fromGossipable(message) {
+        return new P2PMessage(message.toBuffer());
+    }
+    static fromMessageData(messageData) {
+        const reader = new BufferReader(messageData);
+        const payload = reader.readBuffer();
+        return new P2PMessage(payload);
+    }
+    toMessageData() {
+        return serializeToBuffer([
+            serializeToBuffer(this.payload.length, this.payload)
+        ]);
+    }
+}
 /**
  * Gossipable
  *
  * Any class which extends gossipable will be able to be Gossiped over the p2p network
  */ export class Gossipable {
-    /** p2p Topic
-   *
-   * - The p2p topic identifier, this determines how the message is handled
-   */ static p2pTopic;
+    cachedId;
+    /** The p2p topic identifier, this determines how the message is handled */ static p2pTopic;
+    /**
+   * A digest of the message information **used for logging only**.
+   * The identifier used for deduplication is `getMsgIdFn` as defined in `encoding.ts` which is a hash over topic and data.
+   */ async p2pMessageIdentifier() {
+        if (this.cachedId) {
+            return this.cachedId;
+        }
+        this.cachedId = await this.generateP2PMessageIdentifier();
+        return this.cachedId;
+    }
+    toMessage() {
+        return this.toBuffer();
+    }
 }

package/dest/p2p/index.d.ts

@@ -1,3 +1,4 @@
+export * from './attestation_utils.js';
 export * from './block_attestation.js';
 export * from './block_proposal.js';
 export * from './consensus_payload.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/p2p/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/p2p/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC"}

package/dest/p2p/index.js

@@ -1,3 +1,4 @@
+export * from './attestation_utils.js';
 export * from './block_attestation.js';
 export * from './block_proposal.js';
 export * from './consensus_payload.js';

package/dest/p2p/interface.d.ts

@@ -1,18 +1,5 @@
-import { Tx } from '../tx/tx.js';
-import { BlockAttestation } from './block_attestation.js';
-import { BlockProposal } from './block_proposal.js';
-import type { Gossipable } from './gossipable.js';
 export interface RawGossipMessage {
     topic: string;
     data: Uint8Array;
 }
-export declare const TopicTypeMap: Record<string, typeof Gossipable>;
-/**
- * Map from topic to deserialiser
- *
- * Used in msgIdFn libp2p to get the p2pMessageIdentifier from a message
- */
-export declare const TopicToDeserializer: {
-    [x: string]: typeof BlockAttestation.fromBuffer | typeof BlockProposal.fromBuffer | typeof Tx.fromBuffer;
-};
 //# sourceMappingURL=interface.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/p2p/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlD,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,CAAC;CAClB;AAGD,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,UAAU,CAI1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;CAI/B,CAAC"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/p2p/interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,CAAC;CAClB"}

package/dest/p2p/interface.js

@@ -1,19 +1 @@
-import { Tx } from '../tx/tx.js';
-import { BlockAttestation } from './block_attestation.js';
-import { BlockProposal } from './block_proposal.js';
-import { TopicType } from './topic_type.js';
-// Force casts as we know that each field here extends Gossipable, and we just want types from Gossipable
-export const TopicTypeMap = {
-    [TopicType.tx]: Tx,
-    [TopicType.block_proposal]: BlockProposal,
-    [TopicType.block_attestation]: BlockAttestation
-};
-/**
- * Map from topic to deserialiser
- *
- * Used in msgIdFn libp2p to get the p2pMessageIdentifier from a message
- */ export const TopicToDeserializer = {
-    [Tx.p2pTopic]: Tx.fromBuffer,
-    [BlockProposal.p2pTopic]: BlockProposal.fromBuffer,
-    [BlockAttestation.p2pTopic]: BlockAttestation.fromBuffer
-};
+export { };

package/dest/p2p/signature_utils.d.ts

@@ -1,23 +1,22 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { Buffer32 } from '@aztec/foundation/buffer';
 export declare enum SignatureDomainSeparator {
     blockProposal = 0,
-    blockAttestation = 1
+    blockAttestation = 1,
+    attestationsAndSigners = 2
 }
 export interface Signable {
-    getPayloadToSign(domainSeparator: SignatureDomainSeparator): Promise<Buffer>;
+    getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer;
 }
 /**
  * Get the hashed payload for the signature of the `Signable`
  * @param s - The `Signable` to sign
  * @returns The hashed payload for the signature of the `Signable`
  */
-export declare function getHashedSignaturePayload(s: Signable, domainSeparator: SignatureDomainSeparator): Promise<Buffer32>;
+export declare function getHashedSignaturePayload(s: Signable, domainSeparator: SignatureDomainSeparator): Buffer32;
 /**
  * Get the hashed payload for the signature of the `Signable` as an Ethereum signed message EIP-712
  * @param s - the `Signable` to sign
  * @returns The hashed payload for the signature of the `Signable` as an Ethereum signed message
  */
-export declare function getHashedSignaturePayloadEthSignedMessage(s: Signable, domainSeparator: SignatureDomainSeparator): Promise<Buffer32>;
+export declare function getHashedSignaturePayloadEthSignedMessage(s: Signable, domainSeparator: SignatureDomainSeparator): Buffer32;
 //# sourceMappingURL=signature_utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"signature_utils.d.ts","sourceRoot":"","sources":["../../src/p2p/signature_utils.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpD,oBAAY,wBAAwB;IAClC,aAAa,IAAI;IACjB,gBAAgB,IAAI;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,gBAAgB,CAAC,eAAe,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC9E;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,CAAC,EAAE,QAAQ,EACX,eAAe,EAAE,wBAAwB,GACxC,OAAO,CAAC,QAAQ,CAAC,CAEnB;AAED;;;;GAIG;AACH,wBAAsB,yCAAyC,CAC7D,CAAC,EAAE,QAAQ,EACX,eAAe,EAAE,wBAAwB,GACxC,OAAO,CAAC,QAAQ,CAAC,CAGnB"}
+{"version":3,"file":"signature_utils.d.ts","sourceRoot":"","sources":["../../src/p2p/signature_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpD,oBAAY,wBAAwB;IAClC,aAAa,IAAI;IACjB,gBAAgB,IAAI;IACpB,sBAAsB,IAAI;CAC3B;AAED,MAAM,WAAW,QAAQ;IACvB,gBAAgB,CAAC,eAAe,EAAE,wBAAwB,GAAG,MAAM,CAAC;CACrE;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,wBAAwB,GAAG,QAAQ,CAE1G;AAED;;;;GAIG;AACH,wBAAgB,yCAAyC,CACvD,CAAC,EAAE,QAAQ,EACX,eAAe,EAAE,wBAAwB,GACxC,QAAQ,CAGV"}

package/dest/p2p/signature_utils.js

@@ -3,20 +3,21 @@ import { keccak256, makeEthSignDigest } from '@aztec/foundation/crypto';
 export var SignatureDomainSeparator = /*#__PURE__*/ function(SignatureDomainSeparator) {
     SignatureDomainSeparator[SignatureDomainSeparator["blockProposal"] = 0] = "blockProposal";
     SignatureDomainSeparator[SignatureDomainSeparator["blockAttestation"] = 1] = "blockAttestation";
+    SignatureDomainSeparator[SignatureDomainSeparator["attestationsAndSigners"] = 2] = "attestationsAndSigners";
     return SignatureDomainSeparator;
 }({});
 /**
  * Get the hashed payload for the signature of the `Signable`
  * @param s - The `Signable` to sign
  * @returns The hashed payload for the signature of the `Signable`
- */ export async function getHashedSignaturePayload(s, domainSeparator) {
-    return Buffer32.fromBuffer(keccak256(await s.getPayloadToSign(domainSeparator)));
+ */ export function getHashedSignaturePayload(s, domainSeparator) {
+    return Buffer32.fromBuffer(keccak256(s.getPayloadToSign(domainSeparator)));
 }
 /**
  * Get the hashed payload for the signature of the `Signable` as an Ethereum signed message EIP-712
  * @param s - the `Signable` to sign
  * @returns The hashed payload for the signature of the `Signable` as an Ethereum signed message
- */ export async function getHashedSignaturePayloadEthSignedMessage(s, domainSeparator) {
-    const payload = await getHashedSignaturePayload(s, domainSeparator);
+ */ export function getHashedSignaturePayloadEthSignedMessage(s, domainSeparator) {
+    const payload = getHashedSignaturePayload(s, domainSeparator);
     return makeEthSignDigest(payload);
 }