@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/p2p/message_validator.d.ts

@@ -0,0 +1,25 @@
+import type { PeerErrorSeverity } from './peer_error.js';
+/**
+ * Result of validating a P2P message.
+ * - 'accept': Message is valid and should be accepted and processed
+ * - 'ignore': Message should be ignored (not propagated or processed, but sender not penalized)
+ * - 'reject': Message is invalid (rejected and sender penalized)
+ */
+export type ValidationResult = {
+    result: 'accept';
+} | {
+    result: 'ignore';
+} | {
+    result: 'reject';
+    severity: PeerErrorSeverity;
+};
+/**
+ * P2PValidator
+ *
+ * A validator for P2P messages, which returns a ValidationResult indicating
+ * whether to accept, ignore, or reject the message
+ */
+export interface P2PValidator<T> {
+    validate(message: T): Promise<ValidationResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZV92YWxpZGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wMnAvbWVzc2FnZV92YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUV6RDs7Ozs7R0FLRztBQUNILE1BQU0sTUFBTSxnQkFBZ0IsR0FDeEI7SUFBRSxNQUFNLEVBQUUsUUFBUSxDQUFBO0NBQUUsR0FDcEI7SUFBRSxNQUFNLEVBQUUsUUFBUSxDQUFBO0NBQUUsR0FDcEI7SUFBRSxNQUFNLEVBQUUsUUFBUSxDQUFDO0lBQUMsUUFBUSxFQUFFLGlCQUFpQixDQUFBO0NBQUUsQ0FBQztBQUV0RDs7Ozs7R0FLRztBQUNILE1BQU0sV0FBVyxZQUFZLENBQUMsQ0FBQztJQUM3QixRQUFRLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztDQUNqRCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"message_validator.d.ts","sourceRoot":"","sources":["../../src/p2p/message_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACjD"}

package/dest/p2p/message_validator.js

@@ -0,0 +1,6 @@
+/**
+ * P2PValidator
+ *
+ * A validator for P2P messages, which returns a ValidationResult indicating
+ * whether to accept, ignore, or reject the message
+ */ export { };

package/dest/p2p/peer_error.d.ts

@@ -0,0 +1,20 @@
+export declare enum PeerErrorSeverity {
+    /**
+     * Not malicious action, but it must not be tolerated
+     * ~2 occurrences will get the peer banned
+     */
+    LowToleranceError = "LowToleranceError",
+    /**
+     * Negative action that can be tolerated only sometimes
+     * ~10 occurrences will get the peer banned
+     */
+    MidToleranceError = "MidToleranceError",
+    /**
+     * Some error that can be tolerated multiple times
+     * ~50 occurrences will get the peer banned
+     */
+    HighToleranceError = "HighToleranceError"
+}
+/** Severities ordered from mildest to harshest. */
+export declare const PeerErrorSeverityByHarshness: readonly [PeerErrorSeverity.HighToleranceError, PeerErrorSeverity.MidToleranceError, PeerErrorSeverity.LowToleranceError];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVlcl9lcnJvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3AycC9wZWVyX2Vycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9CQUFZLGlCQUFpQjtJQUMzQjs7O09BR0c7SUFDSCxpQkFBaUIsc0JBQXNCO0lBQ3ZDOzs7T0FHRztJQUNILGlCQUFpQixzQkFBc0I7SUFDdkM7OztPQUdHO0lBQ0gsa0JBQWtCLHVCQUF1QjtDQUMxQztBQUVELG1EQUFtRDtBQUNuRCxlQUFPLE1BQU0sNEJBQTRCLDJIQUkvQixDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"peer_error.d.ts","sourceRoot":"","sources":["../../src/p2p/peer_error.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IAC3B;;;OAGG;IACH,iBAAiB,sBAAsB;IACvC;;;OAGG;IACH,iBAAiB,sBAAsB;IACvC;;;OAGG;IACH,kBAAkB,uBAAuB;CAC1C;AAED,mDAAmD;AACnD,eAAO,MAAM,4BAA4B,2HAI/B,CAAC"}

package/dest/p2p/peer_error.js

@@ -0,0 +1,20 @@
+export var PeerErrorSeverity = /*#__PURE__*/ function(PeerErrorSeverity) {
+    /**
+   * Not malicious action, but it must not be tolerated
+   * ~2 occurrences will get the peer banned
+   */ PeerErrorSeverity["LowToleranceError"] = "LowToleranceError";
+    /**
+   * Negative action that can be tolerated only sometimes
+   * ~10 occurrences will get the peer banned
+   */ PeerErrorSeverity["MidToleranceError"] = "MidToleranceError";
+    /**
+   * Some error that can be tolerated multiple times
+   * ~50 occurrences will get the peer banned
+   */ PeerErrorSeverity["HighToleranceError"] = "HighToleranceError";
+    return PeerErrorSeverity;
+}({});
+/** Severities ordered from mildest to harshest. */ export const PeerErrorSeverityByHarshness = [
+    "HighToleranceError",
+    "MidToleranceError",
+    "LowToleranceError"
+];

package/dest/p2p/signature_utils.d.ts

@@ -0,0 +1,42 @@
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { Signature } from '@aztec-labs/foundation/eth-signature';
+import { type BufferReader } from '@aztec-labs/foundation/serialize';
+import { type TypedDataDefinition } from 'viem';
+import type { ZodFor } from '../schemas/index.js';
+export type CoordinationSignatureType = 'BlockProposal' | 'CheckpointProposal' | 'CheckpointAttestation' | 'AttestationsAndSigners' | 'SignedTxs';
+export type CoordinationSignatureContext = {
+    chainId: number;
+    rollupAddress: EthAddress;
+};
+export declare const EMPTY_COORDINATION_SIGNATURE_CONTEXT: CoordinationSignatureContext;
+export declare const coordinationSignatureContextSchema: ZodFor<CoordinationSignatureContext>;
+export interface Signable {
+    readonly primaryType: CoordinationSignatureType;
+    readonly signatureContext: CoordinationSignatureContext;
+    getPayloadToSign(): Buffer;
+}
+export declare function coordinationSignatureContextEquals(a: CoordinationSignatureContext, b: CoordinationSignatureContext): boolean;
+export declare function serializeCoordinationSignatureContext(ctx: CoordinationSignatureContext): Buffer;
+export declare function readCoordinationSignatureContext(reader: BufferReader): CoordinationSignatureContext;
+/**
+ * Returns true if the signable carries a context matching the node's expected context.
+ * Use this at the P2P ingress boundary to reject foreign-chain messages cheaply before
+ * performing any signature recovery.
+ */
+export declare function hasValidSignatureContext(signable: Signable, expected: CoordinationSignatureContext): boolean;
+export declare function getCoordinationSignatureTypedDataForPayloadHash(payloadHash: Buffer32, type: CoordinationSignatureType, context: CoordinationSignatureContext): TypedDataDefinition;
+export declare function getCoordinationSignatureTypedData(signable: Signable): TypedDataDefinition;
+export declare function getHashedSignaturePayloadTypedData(signable: Signable): Buffer32;
+/**
+ * Recovers the sender of a gossiped coordination message. Deliberately lenient (allowYParityAsV): a
+ * signature whose recovery byte is in yParity form (v ∈ {0, 1}) still resolves to its sender, so the P2P
+ * layer can attribute and accept it and then canonicalize on ingress (CheckpointAttestation.
+ * withNormalizedSignature, A-1351) before it reaches the L1 bundle. This is intentionally looser than
+ * on-chain checkpoint validation (getAttestationInfoFromPayload), which recovers strictly to mirror L1's
+ * ECDSA.recover — do not unify the two. These proposal/attestation signatures are P2P-only and never reach
+ * L1 verbatim, so leniency here cannot leak a non-canonical byte onto L1.
+ */
+export declare function recoverCoordinationSigner(signable: Signable, signature: Signature): EthAddress | undefined;
+export declare function getHashedSignaturePayload(s: Signable): Buffer32;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmF0dXJlX3V0aWxzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcDJwL3NpZ25hdHVyZV91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFHekQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBcUIsTUFBTSxrQ0FBa0MsQ0FBQztBQUN4RixPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBaUIsTUFBTSxNQUFNLENBQUM7QUFHL0QsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFbEQsTUFBTSxNQUFNLHlCQUF5QixHQUNqQyxlQUFlLEdBQ2Ysb0JBQW9CLEdBQ3BCLHVCQUF1QixHQUN2Qix3QkFBd0IsR0FDeEIsV0FBVyxDQUFDO0FBRWhCLE1BQU0sTUFBTSw0QkFBNEIsR0FBRztJQUN6QyxPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLGFBQWEsRUFBRSxVQUFVLENBQUM7Q0FDM0IsQ0FBQztBQUVGLGVBQU8sTUFBTSxvQ0FBb0MsRUFBRSw0QkFHbEQsQ0FBQztBQUVGLGVBQU8sTUFBTSxrQ0FBa0MsRUFBRSxNQUFNLENBQUMsNEJBQTRCLENBR2xGLENBQUM7QUFFSCxNQUFNLFdBQVcsUUFBUTtJQUN2QixRQUFRLENBQUMsV0FBVyxFQUFFLHlCQUF5QixDQUFDO0lBQ2hELFFBQVEsQ0FBQyxnQkFBZ0IsRUFBRSw0QkFBNEIsQ0FBQztJQUN4RCxnQkFBZ0IsSUFBSSxNQUFNLENBQUM7Q0FDNUI7QUFFRCx3QkFBZ0Isa0NBQWtDLENBQ2hELENBQUMsRUFBRSw0QkFBNEIsRUFDL0IsQ0FBQyxFQUFFLDRCQUE0QixHQUM5QixPQUFPLENBRVQ7QUFFRCx3QkFBZ0IscUNBQXFDLENBQUMsR0FBRyxFQUFFLDRCQUE0QixHQUFHLE1BQU0sQ0FFL0Y7QUFFRCx3QkFBZ0IsZ0NBQWdDLENBQUMsTUFBTSxFQUFFLFlBQVksR0FBRyw0QkFBNEIsQ0FJbkc7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQWdCLHdCQUF3QixDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLDRCQUE0QixHQUFHLE9BQU8sQ0FFNUc7QUFxQkQsd0JBQWdCLCtDQUErQyxDQUM3RCxXQUFXLEVBQUUsUUFBUSxFQUNyQixJQUFJLEVBQUUseUJBQXlCLEVBQy9CLE9BQU8sRUFBRSw0QkFBNEIsR0FDcEMsbUJBQW1CLENBY3JCO0FBRUQsd0JBQWdCLGlDQUFpQyxDQUFDLFFBQVEsRUFBRSxRQUFRLEdBQUcsbUJBQW1CLENBR3pGO0FBRUQsd0JBQWdCLGtDQUFrQyxDQUFDLFFBQVEsRUFBRSxRQUFRLEdBQUcsUUFBUSxDQUUvRTtBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQWdCLHlCQUF5QixDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLFNBQVMsR0FBRyxVQUFVLEdBQUcsU0FBUyxDQUcxRztBQUVELHdCQUFnQix5QkFBeUIsQ0FBQyxDQUFDLEVBQUUsUUFBUSxHQUFHLFFBQVEsQ0FFL0QifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"signature_utils.d.ts","sourceRoot":"","sources":["../../src/p2p/signature_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAGzD,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,EAAE,KAAK,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AACxF,OAAO,EAAE,KAAK,mBAAmB,EAAiB,MAAM,MAAM,CAAC;AAG/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,MAAM,MAAM,yBAAyB,GACjC,eAAe,GACf,oBAAoB,GACpB,uBAAuB,GACvB,wBAAwB,GACxB,WAAW,CAAC;AAEhB,MAAM,MAAM,4BAA4B,GAAG;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,UAAU,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,4BAGlD,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,4BAA4B,CAGlF,CAAC;AAEH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAC;IAChD,QAAQ,CAAC,gBAAgB,EAAE,4BAA4B,CAAC;IACxD,gBAAgB,IAAI,MAAM,CAAC;CAC5B;AAED,wBAAgB,kCAAkC,CAChD,CAAC,EAAE,4BAA4B,EAC/B,CAAC,EAAE,4BAA4B,GAC9B,OAAO,CAET;AAED,wBAAgB,qCAAqC,CAAC,GAAG,EAAE,4BAA4B,GAAG,MAAM,CAE/F;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,YAAY,GAAG,4BAA4B,CAInG;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,4BAA4B,GAAG,OAAO,CAE5G;AAqBD,wBAAgB,+CAA+C,CAC7D,WAAW,EAAE,QAAQ,EACrB,IAAI,EAAE,yBAAyB,EAC/B,OAAO,EAAE,4BAA4B,GACpC,mBAAmB,CAcrB;AAED,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,CAGzF;AAED,wBAAgB,kCAAkC,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAE/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,CAG1G;AAED,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAE/D"}

package/dest/p2p/signature_utils.js

@@ -0,0 +1,131 @@
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { keccak256 } from '@aztec-labs/foundation/crypto/keccak';
+import { tryRecoverAddress } from '@aztec-labs/foundation/crypto/secp256k1-signer';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { hashTypedData } from 'viem';
+import { z } from 'zod';
+export const EMPTY_COORDINATION_SIGNATURE_CONTEXT = {
+    chainId: 0,
+    rollupAddress: EthAddress.ZERO
+};
+export const coordinationSignatureContextSchema = z.object({
+    chainId: z.number(),
+    rollupAddress: EthAddress.schema
+});
+export function coordinationSignatureContextEquals(a, b) {
+    return a.chainId === b.chainId && a.rollupAddress.equals(b.rollupAddress);
+}
+export function serializeCoordinationSignatureContext(ctx) {
+    return serializeToBuffer([
+        ctx.chainId,
+        ctx.rollupAddress
+    ]);
+}
+export function readCoordinationSignatureContext(reader) {
+    const chainId = reader.readNumber();
+    const rollupAddress = reader.readObject(EthAddress);
+    return {
+        chainId,
+        rollupAddress
+    };
+}
+/**
+ * Returns true if the signable carries a context matching the node's expected context.
+ * Use this at the P2P ingress boundary to reject foreign-chain messages cheaply before
+ * performing any signature recovery.
+ */ export function hasValidSignatureContext(signable, expected) {
+    return coordinationSignatureContextEquals(signable.signatureContext, expected);
+}
+const COORDINATION_SIGNATURE_NAME = 'Aztec Rollup';
+const COORDINATION_SIGNATURE_VERSION = '1';
+const EIP712_DOMAIN_FIELDS = [
+    {
+        name: 'name',
+        type: 'string'
+    },
+    {
+        name: 'version',
+        type: 'string'
+    },
+    {
+        name: 'chainId',
+        type: 'uint256'
+    },
+    {
+        name: 'verifyingContract',
+        type: 'address'
+    }
+];
+const COORDINATION_SIGNATURE_TYPES = {
+    EIP712Domain: EIP712_DOMAIN_FIELDS,
+    BlockProposal: [
+        {
+            name: 'payloadHash',
+            type: 'bytes32'
+        }
+    ],
+    CheckpointProposal: [
+        {
+            name: 'payloadHash',
+            type: 'bytes32'
+        }
+    ],
+    CheckpointAttestation: [
+        {
+            name: 'payloadHash',
+            type: 'bytes32'
+        }
+    ],
+    AttestationsAndSigners: [
+        {
+            name: 'payloadHash',
+            type: 'bytes32'
+        }
+    ],
+    SignedTxs: [
+        {
+            name: 'payloadHash',
+            type: 'bytes32'
+        }
+    ]
+};
+export function getCoordinationSignatureTypedDataForPayloadHash(payloadHash, type, context) {
+    return {
+        domain: {
+            name: COORDINATION_SIGNATURE_NAME,
+            version: COORDINATION_SIGNATURE_VERSION,
+            chainId: context.chainId,
+            verifyingContract: context.rollupAddress.toString()
+        },
+        types: COORDINATION_SIGNATURE_TYPES,
+        primaryType: type,
+        message: {
+            payloadHash: payloadHash.toString()
+        }
+    };
+}
+export function getCoordinationSignatureTypedData(signable) {
+    const payloadHash = getHashedSignaturePayload(signable);
+    return getCoordinationSignatureTypedDataForPayloadHash(payloadHash, signable.primaryType, signable.signatureContext);
+}
+export function getHashedSignaturePayloadTypedData(signable) {
+    return Buffer32.fromString(hashTypedData(getCoordinationSignatureTypedData(signable)));
+}
+/**
+ * Recovers the sender of a gossiped coordination message. Deliberately lenient (allowYParityAsV): a
+ * signature whose recovery byte is in yParity form (v ∈ {0, 1}) still resolves to its sender, so the P2P
+ * layer can attribute and accept it and then canonicalize on ingress (CheckpointAttestation.
+ * withNormalizedSignature, A-1351) before it reaches the L1 bundle. This is intentionally looser than
+ * on-chain checkpoint validation (getAttestationInfoFromPayload), which recovers strictly to mirror L1's
+ * ECDSA.recover — do not unify the two. These proposal/attestation signatures are P2P-only and never reach
+ * L1 verbatim, so leniency here cannot leak a non-canonical byte onto L1.
+ */ export function recoverCoordinationSigner(signable, signature) {
+    const digest = getHashedSignaturePayloadTypedData(signable);
+    return tryRecoverAddress(digest, signature, {
+        allowYParityAsV: true
+    });
+}
+export function getHashedSignaturePayload(s) {
+    return Buffer32.fromBuffer(keccak256(s.getPayloadToSign()));
+}

package/dest/p2p/signed_txs.d.ts

@@ -0,0 +1,44 @@
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { Signature } from '@aztec-labs/foundation/eth-signature';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import type { TypedDataDefinition } from 'viem';
+import { Tx } from '../tx/tx.js';
+import { type CoordinationSignatureContext, type CoordinationSignatureType, type Signable } from './signature_utils.js';
+/**
+ * A signed collection of transactions.
+ * The signature is over the transaction objects themselves, providing
+ * data availability guarantees beyond just the transaction hashes.
+ */
+export declare class SignedTxs implements Signable {
+    /** The transactions */
+    readonly txs: Tx[];
+    /** The proposer's signature over the transactions */
+    readonly signature: Signature;
+    /** The signing domain (chainId + rollupAddress) the signature is bound to */
+    readonly signatureContext: CoordinationSignatureContext;
+    readonly primaryType: CoordinationSignatureType;
+    private cachedSender;
+    constructor(
+    /** The transactions */
+    txs: Tx[], 
+    /** The proposer's signature over the transactions */
+    signature: Signature, 
+    /** The signing domain (chainId + rollupAddress) the signature is bound to */
+    signatureContext: CoordinationSignatureContext);
+    getPayloadToSign(): Buffer;
+    /**
+     * Lazily evaluate the sender of the signed txs; result is cached.
+     * @returns The sender address, or undefined if signature recovery fails
+     */
+    getSender(): EthAddress | undefined;
+    /**
+     * Create SignedTxs from a typed-data signer function
+     */
+    static createFromSigner(txs: Tx[], signatureContext: CoordinationSignatureContext, typedDataSigner: (typedData: TypedDataDefinition) => Promise<Signature>): Promise<SignedTxs>;
+    toBuffer(): Buffer;
+    static fromBuffer(buf: Buffer | BufferReader): SignedTxs;
+    getSize(): number;
+    static empty(): SignedTxs;
+    static random(): SignedTxs;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmVkX3R4cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3AycC9zaWduZWRfdHhzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNqRSxPQUFPLEVBQUUsWUFBWSxFQUFxQixNQUFNLGtDQUFrQyxDQUFDO0FBQ25GLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sTUFBTSxDQUFDO0FBR2hELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDakMsT0FBTyxFQUNMLEtBQUssNEJBQTRCLEVBQ2pDLEtBQUsseUJBQXlCLEVBRTlCLEtBQUssUUFBUSxFQUtkLE1BQU0sc0JBQXNCLENBQUM7QUFFOUI7Ozs7R0FJRztBQUNILHFCQUFhLFNBQVUsWUFBVyxRQUFRO0lBTXRDLHVCQUF1QjthQUNQLEdBQUcsRUFBRSxFQUFFLEVBQUU7SUFDekIscURBQXFEO2FBQ3JDLFNBQVMsRUFBRSxTQUFTO0lBQ3BDLDZFQUE2RTthQUM3RCxnQkFBZ0IsRUFBRSw0QkFBNEI7SUFWaEUsUUFBUSxDQUFDLFdBQVcsRUFBRSx5QkFBeUIsQ0FBZTtJQUU5RCxPQUFPLENBQUMsWUFBWSxDQUE0QztJQUVoRTtJQUNFLHVCQUF1QjtJQUNQLEdBQUcsRUFBRSxFQUFFLEVBQUU7SUFDekIscURBQXFEO0lBQ3JDLFNBQVMsRUFBRSxTQUFTO0lBQ3BDLDZFQUE2RTtJQUM3RCxnQkFBZ0IsRUFBRSw0QkFBNEIsRUFDNUQ7SUFFSixnQkFBZ0IsSUFBSSxNQUFNLENBRXpCO0lBRUQ7OztPQUdHO0lBQ0gsU0FBUyxJQUFJLFVBQVUsR0FBRyxTQUFTLENBS2xDO0lBRUQ7O09BRUc7SUFDSCxPQUFhLGdCQUFnQixDQUMzQixHQUFHLEVBQUUsRUFBRSxFQUFFLEVBQ1QsZ0JBQWdCLEVBQUUsNEJBQTRCLEVBQzlDLGVBQWUsRUFBRSxDQUFDLFNBQVMsRUFBRSxtQkFBbUIsS0FBSyxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQ3RFLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FLcEI7SUFFRCxRQUFRLElBQUksTUFBTSxDQU9qQjtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsR0FBRyxFQUFFLE1BQU0sR0FBRyxZQUFZLEdBQUcsU0FBUyxDQVV2RDtJQUVELE9BQU8sSUFBSSxNQUFNLENBUWhCO0lBRUQsTUFBTSxDQUFDLEtBQUssSUFBSSxTQUFTLENBRXhCO0lBRUQsTUFBTSxDQUFDLE1BQU0sSUFBSSxTQUFTLENBRXpCO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"signed_txs.d.ts","sourceRoot":"","sources":["../../src/p2p/signed_txs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAGhD,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACjC,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,yBAAyB,EAE9B,KAAK,QAAQ,EAKd,MAAM,sBAAsB,CAAC;AAE9B;;;;GAIG;AACH,qBAAa,SAAU,YAAW,QAAQ;IAMtC,uBAAuB;aACP,GAAG,EAAE,EAAE,EAAE;IACzB,qDAAqD;aACrC,SAAS,EAAE,SAAS;IACpC,6EAA6E;aAC7D,gBAAgB,EAAE,4BAA4B;IAVhE,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAe;IAE9D,OAAO,CAAC,YAAY,CAA4C;IAEhE;IACE,uBAAuB;IACP,GAAG,EAAE,EAAE,EAAE;IACzB,qDAAqD;IACrC,SAAS,EAAE,SAAS;IACpC,6EAA6E;IAC7D,gBAAgB,EAAE,4BAA4B,EAC5D;IAEJ,gBAAgB,IAAI,MAAM,CAEzB;IAED;;;OAGG;IACH,SAAS,IAAI,UAAU,GAAG,SAAS,CAKlC;IAED;;OAEG;IACH,OAAa,gBAAgB,CAC3B,GAAG,EAAE,EAAE,EAAE,EACT,gBAAgB,EAAE,4BAA4B,EAC9C,eAAe,EAAE,CAAC,SAAS,EAAE,mBAAmB,KAAK,OAAO,CAAC,SAAS,CAAC,GACtE,OAAO,CAAC,SAAS,CAAC,CAKpB;IAED,QAAQ,IAAI,MAAM,CAOjB;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAUvD;IAED,OAAO,IAAI,MAAM,CAQhB;IAED,MAAM,CAAC,KAAK,IAAI,SAAS,CAExB;IAED,MAAM,CAAC,MAAM,IAAI,SAAS,CAEzB;CACF"}

package/dest/p2p/signed_txs.js

@@ -0,0 +1,77 @@
+import { Signature } from '@aztec-labs/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
+import { Tx } from '../tx/tx.js';
+import { EMPTY_COORDINATION_SIGNATURE_CONTEXT, getCoordinationSignatureTypedData, readCoordinationSignatureContext, recoverCoordinationSigner, serializeCoordinationSignatureContext } from './signature_utils.js';
+/**
+ * A signed collection of transactions.
+ * The signature is over the transaction objects themselves, providing
+ * data availability guarantees beyond just the transaction hashes.
+ */ export class SignedTxs {
+    txs;
+    signature;
+    signatureContext;
+    primaryType;
+    cachedSender;
+    constructor(/** The transactions */ txs, /** The proposer's signature over the transactions */ signature, /** The signing domain (chainId + rollupAddress) the signature is bound to */ signatureContext){
+        this.txs = txs;
+        this.signature = signature;
+        this.signatureContext = signatureContext;
+        this.primaryType = 'SignedTxs';
+        this.cachedSender = undefined;
+    }
+    getPayloadToSign() {
+        return serializeToBuffer([
+            this.txs.length,
+            this.txs
+        ]);
+    }
+    /**
+   * Lazily evaluate the sender of the signed txs; result is cached.
+   * @returns The sender address, or undefined if signature recovery fails
+   */ getSender() {
+        if (this.cachedSender === undefined) {
+            this.cachedSender = recoverCoordinationSigner(this, this.signature) ?? null;
+        }
+        return this.cachedSender ?? undefined;
+    }
+    /**
+   * Create SignedTxs from a typed-data signer function
+   */ static async createFromSigner(txs, signatureContext, typedDataSigner) {
+        const tempSignedTxs = new SignedTxs(txs, Signature.empty(), signatureContext);
+        const typedData = getCoordinationSignatureTypedData(tempSignedTxs);
+        const signature = await typedDataSigner(typedData);
+        return new SignedTxs(txs, signature, signatureContext);
+    }
+    toBuffer() {
+        return serializeToBuffer([
+            this.txs.length,
+            this.txs,
+            this.signature,
+            serializeCoordinationSignatureContext(this.signatureContext)
+        ]);
+    }
+    static fromBuffer(buf) {
+        const reader = BufferReader.asReader(buf);
+        const txCount = reader.readNumber();
+        if (txCount > MAX_TXS_PER_BLOCK) {
+            throw new Error(`txs count ${txCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+        }
+        const txs = reader.readArray(txCount, Tx);
+        const signature = reader.readObject(Signature);
+        const signatureContext = readCoordinationSignatureContext(reader);
+        return new SignedTxs(txs, signature, signatureContext);
+    }
+    getSize() {
+        return 4 /* txs.length */  + this.txs.reduce((acc, tx)=>acc + tx.getSize(), 0) + this.signature.getSize() + 4 /* chainId */  + 20 /* rollupAddress */ ;
+    }
+    static empty() {
+        return new SignedTxs([], Signature.empty(), EMPTY_COORDINATION_SIGNATURE_CONTEXT);
+    }
+    static random() {
+        return new SignedTxs([
+            Tx.random(),
+            Tx.random()
+        ], Signature.random(), EMPTY_COORDINATION_SIGNATURE_CONTEXT);
+    }
+}

package/dest/p2p/topic_type.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Creates the topic channel identifier string from a given topic type
+ */
+export declare function createTopicString(topicType: TopicType, protocolVersion: string): string;
+/** Extracts the topic type from a topic string */
+export declare function getTopicFromString(topicStr: string): TopicType | undefined;
+export declare enum TopicType {
+    tx = "tx",
+    block_proposal = "block_proposal",
+    checkpoint_proposal = "checkpoint_proposal",
+    checkpoint_attestation = "checkpoint_attestation"
+}
+/** Returns all gossip topics, optionally filtering out transactions. */
+export declare function getTopicsForConfig(disableTransactions: boolean): TopicType[];
+/**
+ * Convert the topic string into a set of labels
+ *
+ * In the form:
+ * {
+ *  "/aztec/tx/0.1.0": "tx",
+ *  ...
+ * }
+ */
+export declare function metricsTopicStrToLabels(protocolVersion: string): Map<string, string>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9waWNfdHlwZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3AycC90b3BpY190eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsd0JBQWdCLGlCQUFpQixDQUFDLFNBQVMsRUFBRSxTQUFTLEVBQUUsZUFBZSxFQUFFLE1BQU0sVUFFOUU7QUFFRCxrREFBa0Q7QUFDbEQsd0JBQWdCLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxNQUFNLEdBQUcsU0FBUyxHQUFHLFNBQVMsQ0FVMUU7QUFFRCxvQkFBWSxTQUFTO0lBQ25CLEVBQUUsT0FBTztJQUNULGNBQWMsbUJBQW1CO0lBQ2pDLG1CQUFtQix3QkFBd0I7SUFDM0Msc0JBQXNCLDJCQUEyQjtDQUNsRDtBQUVELHdFQUF3RTtBQUN4RSx3QkFBZ0Isa0JBQWtCLENBQUMsbUJBQW1CLEVBQUUsT0FBTyxlQVc5RDtBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQWdCLHVCQUF1QixDQUFDLGVBQWUsRUFBRSxNQUFNLHVCQU85RCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"topic_type.d.ts","sourceRoot":"","sources":["../../src/p2p/topic_type.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,UAE9E;AAED,kDAAkD;AAClD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAU1E;AAED,oBAAY,SAAS;IACnB,EAAE,OAAO;IACT,cAAc,mBAAmB;IACjC,mBAAmB,wBAAwB;IAC3C,sBAAsB,2BAA2B;CAClD;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,mBAAmB,EAAE,OAAO,eAW9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,MAAM,uBAO9D"}

package/dest/p2p/topic_type.js

@@ -0,0 +1,50 @@
+/**
+ * Creates the topic channel identifier string from a given topic type
+ */ export function createTopicString(topicType, protocolVersion) {
+    return `/aztec/${TopicType[topicType]}/${protocolVersion}`;
+}
+/** Extracts the topic type from a topic string */ export function getTopicFromString(topicStr) {
+    const parts = topicStr.split('/');
+    if (parts.length < 4 || parts[1] !== 'aztec') {
+        return undefined;
+    }
+    const topic = parts[2];
+    if (Object.values(TopicType).includes(topic)) {
+        return topic;
+    }
+    return undefined;
+}
+export var TopicType = /*#__PURE__*/ function(TopicType) {
+    TopicType["tx"] = "tx";
+    TopicType["block_proposal"] = "block_proposal";
+    TopicType["checkpoint_proposal"] = "checkpoint_proposal";
+    TopicType["checkpoint_attestation"] = "checkpoint_attestation";
+    return TopicType;
+}({});
+/** Returns all gossip topics, optionally filtering out transactions. */ export function getTopicsForConfig(disableTransactions) {
+    const topics = [
+        "tx",
+        "block_proposal",
+        "checkpoint_proposal",
+        "checkpoint_attestation"
+    ];
+    if (disableTransactions) {
+        return topics.filter((topic)=>topic !== "tx");
+    }
+    return topics;
+}
+/**
+ * Convert the topic string into a set of labels
+ *
+ * In the form:
+ * {
+ *  "/aztec/tx/0.1.0": "tx",
+ *  ...
+ * }
+ */ export function metricsTopicStrToLabels(protocolVersion) {
+    const topicStrToLabel = new Map();
+    for(const topic in TopicType){
+        topicStrToLabel.set(createTopicString(TopicType[topic], protocolVersion), topic);
+    }
+    return topicStrToLabel;
+}

package/dest/p2p/validated_proposal.d.ts

@@ -0,0 +1,35 @@
+import type { Branded } from '@aztec-labs/foundation/branded-types';
+import type { BlockProposal } from './block_proposal.js';
+import type { CheckpointProposalCore } from './checkpoint_proposal.js';
+/**
+ * A block proposal that has passed p2p ingress validation.
+ *
+ * Downstream consumers (the validator client's proposal handlers) rely on that validation having already
+ * happened and do not repeat it, so this brand marks the proposals they are allowed to receive. It is a
+ * compile-time marker only: at runtime a `ValidatedBlockProposal` is just a `BlockProposal`.
+ */
+export type ValidatedBlockProposal = Branded<BlockProposal, 'ValidatedBlockProposal'>;
+/**
+ * Marks a block proposal as having passed p2p ingress validation.
+ *
+ * May only be called at a point where the gossipsub topic validator has accepted the proposal, which covers
+ * the signature context, the signature itself, the expected proposer for the slot, the index within the
+ * checkpoint, the tx field checks, and the receive-window timeliness check.
+ */
+export declare function ValidatedBlockProposal(proposal: BlockProposal): ValidatedBlockProposal;
+/**
+ * A checkpoint proposal (without its last block) that has passed p2p ingress validation.
+ *
+ * Downstream consumers (the validator client's proposal handlers) rely on that validation having already
+ * happened and do not repeat it, so this brand marks the proposals they are allowed to receive. It is a
+ * compile-time marker only: at runtime a `ValidatedCheckpointProposalCore` is just a `CheckpointProposalCore`.
+ */
+export type ValidatedCheckpointProposalCore = Branded<CheckpointProposalCore, 'ValidatedCheckpointProposalCore'>;
+/**
+ * Marks a checkpoint proposal as having passed p2p ingress validation.
+ *
+ * May only be called at a point where the gossipsub topic validator has accepted the proposal, which covers
+ * the expected proposer for the slot and the receive-window timeliness check.
+ */
+export declare function ValidatedCheckpointProposalCore(proposal: CheckpointProposalCore): ValidatedCheckpointProposalCore;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGVkX3Byb3Bvc2FsLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcDJwL3ZhbGlkYXRlZF9wcm9wb3NhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUVwRSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXZFOzs7Ozs7R0FNRztBQUNILE1BQU0sTUFBTSxzQkFBc0IsR0FBRyxPQUFPLENBQUMsYUFBYSxFQUFFLHdCQUF3QixDQUFDLENBQUM7QUFFdEY7Ozs7OztHQU1HO0FBQ0gsd0JBQWdCLHNCQUFzQixDQUFDLFFBQVEsRUFBRSxhQUFhLEdBQUcsc0JBQXNCLENBRXRGO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxNQUFNLCtCQUErQixHQUFHLE9BQU8sQ0FBQyxzQkFBc0IsRUFBRSxpQ0FBaUMsQ0FBQyxDQUFDO0FBRWpIOzs7OztHQUtHO0FBQ0gsd0JBQWdCLCtCQUErQixDQUFDLFFBQVEsRUFBRSxzQkFBc0IsR0FBRywrQkFBK0IsQ0FFakgifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"validated_proposal.d.ts","sourceRoot":"","sources":["../../src/p2p/validated_proposal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AAEpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,aAAa,EAAE,wBAAwB,CAAC,CAAC;AAEtF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,aAAa,GAAG,sBAAsB,CAEtF;AAED;;;;;;GAMG;AACH,MAAM,MAAM,+BAA+B,GAAG,OAAO,CAAC,sBAAsB,EAAE,iCAAiC,CAAC,CAAC;AAEjH;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,+BAA+B,CAEjH"}

package/dest/p2p/validated_proposal.js

@@ -0,0 +1,17 @@
+/**
+ * Marks a block proposal as having passed p2p ingress validation.
+ *
+ * May only be called at a point where the gossipsub topic validator has accepted the proposal, which covers
+ * the signature context, the signature itself, the expected proposer for the slot, the index within the
+ * checkpoint, the tx field checks, and the receive-window timeliness check.
+ */ export function ValidatedBlockProposal(proposal) {
+    return proposal;
+}
+/**
+ * Marks a checkpoint proposal as having passed p2p ingress validation.
+ *
+ * May only be called at a point where the gossipsub topic validator has accepted the proposal, which covers
+ * the expected proposer for the slot and the receive-window timeliness check.
+ */ export function ValidatedCheckpointProposalCore(proposal) {
+    return proposal;
+}

package/dest/p2p/wire_compat_fixtures.d.ts

@@ -0,0 +1,7 @@
+/** Legacy `BlockProposal.toBuffer()` bytes (no signedTxs, no bucket reference). */
+export declare const LEGACY_BLOCK_PROPOSAL_HEX = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000630000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000007000000000000000000000000000000000000000000000000000000000000000800000000";
+/** Legacy `CheckpointProposal.toBuffer()` bytes (lastBlock without signedTxs or bucket reference). */
+export declare const LEGACY_CHECKPOINT_PROPOSAL_HEX = "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000700000000";
+/** Legacy `BlockProposal.getPayloadToSign()` bytes (no bucket reference). */
+export declare const LEGACY_BLOCK_PROPOSAL_PAYLOAD_HEX = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000630000000200000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000008";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2lyZV9jb21wYXRfZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wMnAvd2lyZV9jb21wYXRfZml4dHVyZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBWUEsbUZBQW1GO0FBQ25GLGVBQU8sTUFBTSx5QkFBeUIsdXdDQUNndUMsQ0FBQztBQUV2d0Msc0dBQXNHO0FBQ3RHLGVBQU8sTUFBTSw4QkFBOEIsK2tFQUNtaUUsQ0FBQztBQUUva0UsNkVBQTZFO0FBQzdFLGVBQU8sTUFBTSxpQ0FBaUMsdWtDQUN3aEMsQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"wire_compat_fixtures.d.ts","sourceRoot":"","sources":["../../src/p2p/wire_compat_fixtures.ts"],"names":[],"mappings":"AAYA,mFAAmF;AACnF,eAAO,MAAM,yBAAyB,uwCACguC,CAAC;AAEvwC,sGAAsG;AACtG,eAAO,MAAM,8BAA8B,+kEACmiE,CAAC;AAE/kE,6EAA6E;AAC7E,eAAO,MAAM,iCAAiC,ukCACwhC,CAAC"}

package/dest/p2p/wire_compat_fixtures.js

@@ -0,0 +1,14 @@
+// Golden wire fixtures that pin the exact bytes a peer produces and consumes, so the optional bucket-reference tail
+// added to proposals stays wire compatible: an unset proposal must serialize to these bytes, and decoding these bytes
+// must yield no bucket reference. The block-proposal fixtures were refreshed for the removal of the legacy `inHash`
+// field; the checkpoint-proposal fixture was refreshed for the checkpoint-header format change.
+//
+// Both fixtures come from a deterministic proposal built with:
+//   BlockHeader.empty(), IndexWithinCheckpoint(3), archiveRoot=Fr(99),
+//   txHashes=[TxHash.fromField(Fr(7)), TxHash.fromField(Fr(8))], Signature.empty(), EMPTY_COORDINATION_SIGNATURE_CONTEXT
+// (checkpoint: CheckpointHeader.empty(), archive=Fr(123), feeAssetPriceModifier=0, empty signature/context, and a
+// lastBlock with BlockHeader.empty(), IndexWithinCheckpoint(4), txHashes=[TxHash.fromField(Fr(7))], empty signature).
+// Regenerate the checkpoint fixture only when the checkpoint serialization format changes on purpose.
+/** Legacy `BlockProposal.toBuffer()` bytes (no signedTxs, no bucket reference). */ export const LEGACY_BLOCK_PROPOSAL_HEX = '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000630000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000007000000000000000000000000000000000000000000000000000000000000000800000000';
+/** Legacy `CheckpointProposal.toBuffer()` bytes (lastBlock without signedTxs or bucket reference). */ export const LEGACY_CHECKPOINT_PROPOSAL_HEX = '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000700000000';
+/** Legacy `BlockProposal.getPayloadToSign()` bytes (no bucket reference). */ export const LEGACY_BLOCK_PROPOSAL_PAYLOAD_HEX = '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000630000000200000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000008';