@aztec/p2p 0.0.0-test.0

package/dest/mem_pools/tx_pool/tx_pool_test_suite.js

@@ -0,0 +1,169 @@
+import { unfreeze } from '@aztec/foundation/types';
+import { GasFees } from '@aztec/stdlib/gas';
+import { mockTx } from '@aztec/stdlib/testing';
+/**
+ * Tests a TxPool implementation.
+ * @param getTxPool - Gets a fresh TxPool
+ */ export function describeTxPool(getTxPool) {
+    let pool;
+    beforeEach(()=>{
+        pool = getTxPool();
+    });
+    it('Adds txs to the pool as pending', async ()=>{
+        const tx1 = await mockTx();
+        await pool.addTxs([
+            tx1
+        ]);
+        const poolTx = await pool.getTxByHash(await tx1.getTxHash());
+        expect(await poolTx.getTxHash()).toEqual(await tx1.getTxHash());
+        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
+        await expect(pool.getPendingTxHashes()).resolves.toEqual([
+            await tx1.getTxHash()
+        ]);
+    });
+    it('Removes txs from the pool', async ()=>{
+        const tx1 = await mockTx();
+        await pool.addTxs([
+            tx1
+        ]);
+        await pool.deleteTxs([
+            await tx1.getTxHash()
+        ]);
+        await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
+        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+    });
+    it('Marks txs as mined', async ()=>{
+        const tx1 = await mockTx(1);
+        const tx2 = await mockTx(2);
+        await pool.addTxs([
+            tx1,
+            tx2
+        ]);
+        await pool.markAsMined([
+            await tx1.getTxHash()
+        ], 1);
+        await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
+        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
+        await expect(pool.getMinedTxHashes()).resolves.toEqual([
+            [
+                await tx1.getTxHash(),
+                1
+            ]
+        ]);
+        await expect(pool.getPendingTxHashes()).resolves.toEqual([
+            await tx2.getTxHash()
+        ]);
+    });
+    it('Marks txs as pending after being mined', async ()=>{
+        const tx1 = await mockTx(1);
+        const tx2 = await mockTx(2);
+        await pool.addTxs([
+            tx1,
+            tx2
+        ]);
+        await pool.markAsMined([
+            await tx1.getTxHash()
+        ], 1);
+        await pool.markMinedAsPending([
+            await tx1.getTxHash()
+        ]);
+        await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+        const pending = await pool.getPendingTxHashes();
+        expect(pending).toHaveLength(2);
+        expect(pending).toEqual(expect.arrayContaining([
+            await tx1.getTxHash(),
+            await tx2.getTxHash()
+        ]));
+    });
+    it('Only marks txs as pending if they are known', async ()=>{
+        const tx1 = await mockTx(1);
+        // simulate a situation where not all peers have all the txs
+        const tx2 = await mockTx(2);
+        const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
+        await pool.addTxs([
+            tx1
+        ]);
+        // this peer knows that tx2 was mined, but it does not have the tx object
+        await pool.markAsMined([
+            await tx1.getTxHash(),
+            someTxHashThatThisPeerDidNotSee
+        ], 1);
+        expect(await pool.getMinedTxHashes()).toEqual(expect.arrayContaining([
+            [
+                await tx1.getTxHash(),
+                1
+            ],
+            [
+                someTxHashThatThisPeerDidNotSee,
+                1
+            ]
+        ]));
+        // reorg: both txs should now become available again
+        await pool.markMinedAsPending([
+            await tx1.getTxHash(),
+            someTxHashThatThisPeerDidNotSee
+        ]);
+        await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+        await expect(pool.getPendingTxHashes()).resolves.toEqual([
+            await tx1.getTxHash()
+        ]); // tx2 is not in the pool
+    });
+    it('Returns all transactions in the pool', async ()=>{
+        const tx1 = await mockTx(1);
+        const tx2 = await mockTx(2);
+        const tx3 = await mockTx(3);
+        await pool.addTxs([
+            tx1,
+            tx2,
+            tx3
+        ]);
+        const poolTxs = await pool.getAllTxs();
+        expect(poolTxs).toHaveLength(3);
+        expect(poolTxs).toEqual(expect.arrayContaining([
+            tx1,
+            tx2,
+            tx3
+        ]));
+    });
+    it('Returns all txHashes in the pool', async ()=>{
+        const tx1 = await mockTx(1);
+        const tx2 = await mockTx(2);
+        const tx3 = await mockTx(3);
+        await pool.addTxs([
+            tx1,
+            tx2,
+            tx3
+        ]);
+        const poolTxHashes = await pool.getAllTxHashes();
+        expect(poolTxHashes).toHaveLength(3);
+        expect(poolTxHashes).toEqual(expect.arrayContaining([
+            await tx1.getTxHash(),
+            await tx2.getTxHash(),
+            await tx3.getTxHash()
+        ]));
+    });
+    it('Returns pending tx hashes sorted by priority', async ()=>{
+        const withPriorityFee = (tx, fee)=>{
+            unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
+            return tx;
+        };
+        const tx1 = withPriorityFee(await mockTx(0), 1000);
+        const tx2 = withPriorityFee(await mockTx(1), 100);
+        const tx3 = withPriorityFee(await mockTx(2), 200);
+        const tx4 = withPriorityFee(await mockTx(3), 3000);
+        await pool.addTxs([
+            tx1,
+            tx2,
+            tx3,
+            tx4
+        ]);
+        const poolTxHashes = await pool.getPendingTxHashes();
+        expect(poolTxHashes).toHaveLength(4);
+        expect(poolTxHashes).toEqual(await Promise.all([
+            tx4,
+            tx1,
+            tx3,
+            tx2
+        ].map((tx)=>tx.getTxHash())));
+    });
+}

package/dest/msg_validators/attestation_validator/attestation_validator.d.ts

@@ -0,0 +1,8 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+export declare class AttestationValidator implements P2PValidator<BlockAttestation> {
+    private epochCache;
+    constructor(epochCache: EpochCacheInterface);
+    validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined>;
+}
+//# sourceMappingURL=attestation_validator.d.ts.map

package/dest/msg_validators/attestation_validator/attestation_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEhG,qBAAa,oBAAqB,YAAW,YAAY,CAAC,gBAAgB,CAAC;IACzE,OAAO,CAAC,UAAU,CAAsB;gBAE5B,UAAU,EAAE,mBAAmB;IAIrC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;CAelF"}

package/dest/msg_validators/attestation_validator/attestation_validator.js

@@ -0,0 +1,19 @@
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+export class AttestationValidator {
+    epochCache;
+    constructor(epochCache){
+        this.epochCache = epochCache;
+    }
+    async validate(message) {
+        const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
+        const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
+        if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        const attester = await message.getSender();
+        if (!await this.epochCache.isInCommittee(attester)) {
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        return undefined;
+    }
+}

package/dest/msg_validators/attestation_validator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './attestation_validator.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/msg_validators/attestation_validator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}

package/dest/msg_validators/attestation_validator/index.js

@@ -0,0 +1 @@
+export * from './attestation_validator.js';

package/dest/msg_validators/block_proposal_validator/block_proposal_validator.d.ts

@@ -0,0 +1,8 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+export declare class BlockProposalValidator implements P2PValidator<BlockProposal> {
+    private epochCache;
+    constructor(epochCache: EpochCacheInterface);
+    validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined>;
+}
+//# sourceMappingURL=block_proposal_validator.d.ts.map

package/dest/msg_validators/block_proposal_validator/block_proposal_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_proposal_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/block_proposal_validator/block_proposal_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE7F,qBAAa,sBAAuB,YAAW,YAAY,CAAC,aAAa,CAAC;IACxE,OAAO,CAAC,UAAU,CAAsB;gBAE5B,UAAU,EAAE,mBAAmB;IAIrC,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;CAkB7E"}

package/dest/msg_validators/block_proposal_validator/block_proposal_validator.js

@@ -0,0 +1,21 @@
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+export class BlockProposalValidator {
+    epochCache;
+    constructor(epochCache){
+        this.epochCache = epochCache;
+    }
+    async validate(block) {
+        const { currentProposer, nextProposer, currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
+        // Check that the attestation is for the current or next slot
+        const slotNumberBigInt = block.payload.header.globalVariables.slotNumber.toBigInt();
+        if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        // Check that the block proposal is from the current or next proposer
+        const proposer = await block.getSender();
+        if (!proposer.equals(currentProposer) && !proposer.equals(nextProposer)) {
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        return undefined;
+    }
+}

package/dest/msg_validators/block_proposal_validator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './block_proposal_validator.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/msg_validators/block_proposal_validator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/block_proposal_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC"}

package/dest/msg_validators/block_proposal_validator/index.js

@@ -0,0 +1 @@
+export * from './block_proposal_validator.js';

package/dest/msg_validators/index.d.ts

@@ -0,0 +1,4 @@
+export * from './tx_validator/index.js';
+export * from './block_proposal_validator/index.js';
+export * from './attestation_validator/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/msg_validators/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,kCAAkC,CAAC"}

package/dest/msg_validators/index.js

@@ -0,0 +1,3 @@
+export * from './tx_validator/index.js';
+export * from './block_proposal_validator/index.js';
+export * from './attestation_validator/index.js';

package/dest/msg_validators/tx_validator/aggregate_tx_validator.d.ts

@@ -0,0 +1,7 @@
+import type { ProcessedTx, Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
+export declare class AggregateTxValidator<T extends Tx | ProcessedTx> implements TxValidator<T> {
+    #private;
+    constructor(...validators: TxValidator<T>[]);
+    validateTx(tx: T): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=aggregate_tx_validator.d.ts.map

package/dest/msg_validators/tx_validator/aggregate_tx_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate_tx_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/aggregate_tx_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEzF,qBAAa,oBAAoB,CAAC,CAAC,SAAS,EAAE,GAAG,WAAW,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;gBAEzE,GAAG,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE;IAQrC,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAmBrD"}

package/dest/msg_validators/tx_validator/aggregate_tx_validator.js

@@ -0,0 +1,31 @@
+export class AggregateTxValidator {
+    #validators;
+    constructor(...validators){
+        if (validators.length === 0) {
+            throw new Error('At least one validator must be provided');
+        }
+        this.#validators = validators;
+    }
+    async validateTx(tx) {
+        const aggregate = {
+            result: 'valid',
+            reason: []
+        };
+        for (const validator of this.#validators){
+            const result = await validator.validateTx(tx);
+            if (result.result === 'invalid') {
+                aggregate.result = 'invalid';
+                aggregate.reason.push(...result.reason);
+            } else if (result.result === 'skipped') {
+                if (aggregate.result === 'valid') {
+                    aggregate.result = 'skipped';
+                }
+                aggregate.reason.push(...result.reason);
+            }
+        }
+        if (aggregate.result === 'valid') {
+            delete aggregate.reason;
+        }
+        return aggregate;
+    }
+}

package/dest/msg_validators/tx_validator/block_header_validator.d.ts

@@ -0,0 +1,11 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { type AnyTx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+export interface ArchiveSource {
+    getArchiveIndices: (archives: Fr[]) => Promise<(bigint | undefined)[]>;
+}
+export declare class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
+    #private;
+    constructor(archiveSource: ArchiveSource);
+    validateTx(tx: T): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=block_header_validator.d.ts.map

package/dest/msg_validators/tx_validator/block_header_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_header_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/block_header_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,KAAK,KAAK,EAAM,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE7F,MAAM,WAAW,aAAa;IAC5B,iBAAiB,EAAE,CAAC,QAAQ,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;CACxE;AAED,qBAAa,sBAAsB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;gBAIhE,aAAa,EAAE,aAAa;IAIlC,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAQrD"}

package/dest/msg_validators/tx_validator/block_header_validator.js

@@ -0,0 +1,26 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Tx } from '@aztec/stdlib/tx';
+export class BlockHeaderTxValidator {
+    #log = createLogger('p2p:tx_validator:tx_block_header');
+    #archiveSource;
+    constructor(archiveSource){
+        this.#archiveSource = archiveSource;
+    }
+    async validateTx(tx) {
+        const [index] = await this.#archiveSource.getArchiveIndices([
+            await tx.data.constants.historicalHeader.hash()
+        ]);
+        if (index === undefined) {
+            this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
+            return {
+                result: 'invalid',
+                reason: [
+                    'Block header not found'
+                ]
+            };
+        }
+        return {
+            result: 'valid'
+        };
+    }
+}

package/dest/msg_validators/tx_validator/data_validator.d.ts

@@ -0,0 +1,6 @@
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+export declare class DataTxValidator implements TxValidator<Tx> {
+    #private;
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=data_validator.d.ts.map

package/dest/msg_validators/tx_validator/data_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/data_validator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEjF,qBAAa,eAAgB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAG/C,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAkGtD"}

package/dest/msg_validators/tx_validator/data_validator.js

@@ -0,0 +1,107 @@
+import { MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
+import { createLogger } from '@aztec/foundation/log';
+import { Tx } from '@aztec/stdlib/tx';
+export class DataTxValidator {
+    #log = createLogger('p2p:tx_validator:tx_data');
+    async validateTx(tx) {
+        const execRequestRes = this.#hasCorrectExecutionRequests(tx);
+        // Note: If we ever skip txs here, must change this return statement to account for them.
+        return (await execRequestRes).result === 'invalid' ? execRequestRes : this.#hasCorrectContractClassLogs(tx);
+    }
+    async #hasCorrectExecutionRequests(tx) {
+        const callRequests = [
+            ...tx.data.getRevertiblePublicCallRequests(),
+            ...tx.data.getNonRevertiblePublicCallRequests()
+        ];
+        if (callRequests.length !== tx.enqueuedPublicFunctionCalls.length) {
+            this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of mismatch number of execution requests for public calls. Expected ${callRequests.length}. Got ${tx.enqueuedPublicFunctionCalls.length}.`);
+            return {
+                result: 'invalid',
+                reason: [
+                    'Wrong number of execution requests for public calls'
+                ]
+            };
+        }
+        if (tx.getTotalPublicArgsCount() > MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS) {
+            this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because the total length of args to public enqueued calls is greater than ${MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS}`);
+            return {
+                result: 'invalid',
+                reason: [
+                    'Too many args in total to enqueued public calls'
+                ]
+            };
+        }
+        const invalidExecutionRequestIndex = (await Promise.all(tx.enqueuedPublicFunctionCalls.map(async (execRequest, i)=>!await execRequest.isForCallRequest(callRequests[i])))).findIndex(Boolean);
+        if (invalidExecutionRequestIndex !== -1) {
+            this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because of incorrect execution requests for public call at index ${invalidExecutionRequestIndex}.`);
+            return {
+                result: 'invalid',
+                reason: [
+                    'Incorrect execution request for public call'
+                ]
+            };
+        }
+        const teardownCallRequest = tx.data.getTeardownPublicCallRequest();
+        const isInvalidTeardownExecutionRequest = !teardownCallRequest && !tx.publicTeardownFunctionCall.isEmpty() || teardownCallRequest && !await tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest);
+        if (isInvalidTeardownExecutionRequest) {
+            this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because of incorrect teardown execution requests.`);
+            return {
+                result: 'invalid',
+                reason: [
+                    'Incorrect teardown execution request'
+                ]
+            };
+        }
+        return {
+            result: 'valid'
+        };
+    }
+    async #hasCorrectContractClassLogs(tx) {
+        const contractClassLogsHashes = tx.data.getNonEmptyContractClassLogsHashes();
+        const hashedContractClasslogs = await Promise.all(tx.contractClassLogs.map((l)=>l.hash()));
+        if (contractClassLogsHashes.length !== hashedContractClasslogs.length) {
+            this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${contractClassLogsHashes.length}. Got ${hashedContractClasslogs.length}.`);
+            return {
+                result: 'invalid',
+                reason: [
+                    'Mismatched number of contract class logs'
+                ]
+            };
+        }
+        for (const [i, logHash] of contractClassLogsHashes.entries()){
+            const hashedLog = hashedContractClasslogs[i];
+            if (!logHash.value.equals(hashedLog)) {
+                if (hashedContractClasslogs.some((l)=>logHash.value.equals(l))) {
+                    const matchingLogIndex = hashedContractClasslogs.findIndex((l)=>logHash.value.equals(l));
+                    this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`);
+                    return {
+                        result: 'invalid',
+                        reason: [
+                            'Incorrectly sorted contract class logs'
+                        ]
+                    };
+                } else {
+                    this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${logHash.value} from the kernels. Got ${hashedLog} in the tx.`);
+                    return {
+                        result: 'invalid',
+                        reason: [
+                            'Mismatched contract class logs'
+                        ]
+                    };
+                }
+            }
+            if (logHash.logHash.length !== tx.contractClassLogs[i].getEmittedLength()) {
+                this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs length. Expected ${logHash.logHash.length} from the kernel's log hashes. Got ${tx.contractClassLogs[i].getEmittedLength()} in the tx.`);
+                return {
+                    result: 'invalid',
+                    reason: [
+                        'Mismatched contract class logs length'
+                    ]
+                };
+            }
+        }
+        return {
+            result: 'valid'
+        };
+    }
+}

package/dest/msg_validators/tx_validator/double_spend_validator.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type AnyTx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+export interface NullifierSource {
+    nullifiersExist: (nullifiers: Buffer[]) => Promise<boolean[]>;
+}
+export declare class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
+    #private;
+    constructor(nullifierSource: NullifierSource);
+    validateTx(tx: T): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=double_spend_validator.d.ts.map

package/dest/msg_validators/tx_validator/double_spend_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"double_spend_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/double_spend_validator.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,KAAK,KAAK,EAAM,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAkB,MAAM,kBAAkB,CAAC;AAE7G,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CAC/D;AAED,qBAAa,sBAAsB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;gBAIhE,eAAe,EAAE,eAAe;IAItC,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAsBrD"}

package/dest/msg_validators/tx_validator/double_spend_validator.js

@@ -0,0 +1,41 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Tx, hasPublicCalls } from '@aztec/stdlib/tx';
+export class DoubleSpendTxValidator {
+    #log = createLogger('p2p:tx_validator:tx_double_spend');
+    #nullifierSource;
+    constructor(nullifierSource){
+        this.#nullifierSource = nullifierSource;
+    }
+    async validateTx(tx) {
+        // Don't need to check for duplicate nullifiers if the tx has public calls
+        // because the AVM will perform merkle insertions as it goes and will fail on
+        // duplicate nullifier. In fact we CANNOT check here because the nullifiers
+        // have already been inserted, and so they will exist in nullifierSource.
+        if (!hasPublicCalls(tx)) {
+            const nullifiers = tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers;
+            // Ditch this tx if it has repeated nullifiers
+            const uniqueNullifiers = new Set(nullifiers);
+            if (uniqueNullifiers.size !== nullifiers.length) {
+                this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for emitting duplicate nullifiers`);
+                return {
+                    result: 'invalid',
+                    reason: [
+                        'Duplicate nullifier in tx'
+                    ]
+                };
+            }
+            if ((await this.#nullifierSource.nullifiersExist(nullifiers.map((n)=>n.toBuffer()))).some(Boolean)) {
+                this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
+                return {
+                    result: 'invalid',
+                    reason: [
+                        'Existing nullifier'
+                    ]
+                };
+            }
+        }
+        return {
+            result: 'valid'
+        };
+    }
+}

package/dest/msg_validators/tx_validator/index.d.ts

@@ -0,0 +1,7 @@
+export * from './aggregate_tx_validator.js';
+export * from './data_validator.js';
+export * from './double_spend_validator.js';
+export * from './metadata_validator.js';
+export * from './tx_proof_validator.js';
+export * from './block_header_validator.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/msg_validators/tx_validator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC"}

package/dest/msg_validators/tx_validator/index.js

@@ -0,0 +1,6 @@
+export * from './aggregate_tx_validator.js';
+export * from './data_validator.js';
+export * from './double_spend_validator.js';
+export * from './metadata_validator.js';
+export * from './tx_proof_validator.js';
+export * from './block_header_validator.js';

package/dest/msg_validators/tx_validator/metadata_validator.d.ts

@@ -0,0 +1,10 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { type AnyTx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+export declare class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
+    #private;
+    private chainId;
+    private blockNumber;
+    constructor(chainId: Fr, blockNumber: Fr);
+    validateTx(tx: T): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=metadata_validator.d.ts.map

package/dest/msg_validators/tx_validator/metadata_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/metadata_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,KAAK,KAAK,EAAM,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE7F,qBAAa,mBAAmB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAG7D,OAAO,CAAC,OAAO;IAAM,OAAO,CAAC,WAAW;gBAAhC,OAAO,EAAE,EAAE,EAAU,WAAW,EAAE,EAAE;IAElD,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAsCrD"}

package/dest/msg_validators/tx_validator/metadata_validator.js

@@ -0,0 +1,44 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Tx } from '@aztec/stdlib/tx';
+export class MetadataTxValidator {
+    chainId;
+    blockNumber;
+    #log;
+    constructor(chainId, blockNumber){
+        this.chainId = chainId;
+        this.blockNumber = blockNumber;
+        this.#log = createLogger('p2p:tx_validator:tx_metadata');
+    }
+    async validateTx(tx) {
+        const errors = [];
+        if (!await this.#hasCorrectChainId(tx)) {
+            errors.push('Incorrect chain id');
+        }
+        if (!await this.#isValidForBlockNumber(tx)) {
+            errors.push('Invalid block number');
+        }
+        return errors.length > 0 ? {
+            result: 'invalid',
+            reason: errors
+        } : {
+            result: 'valid'
+        };
+    }
+    async #hasCorrectChainId(tx) {
+        if (!tx.data.constants.txContext.chainId.equals(this.chainId)) {
+            this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.chainId.toNumber()}`);
+            return false;
+        } else {
+            return true;
+        }
+    }
+    async #isValidForBlockNumber(tx) {
+        const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+        if (maxBlockNumber.isSome && maxBlockNumber.value < this.blockNumber) {
+            this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${maxBlockNumber.value}, current block number: ${this.blockNumber}.`);
+            return false;
+        } else {
+            return true;
+        }
+    }
+}

package/dest/msg_validators/tx_validator/tx_proof_validator.d.ts

@@ -0,0 +1,9 @@
+import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+export declare class TxProofValidator implements TxValidator<Tx> {
+    #private;
+    private verifier;
+    constructor(verifier: ClientProtocolCircuitVerifier);
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=tx_proof_validator.d.ts.map

package/dest/msg_validators/tx_validator/tx_proof_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_proof_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/tx_proof_validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,EAAE,EAAE,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEjF,qBAAa,gBAAiB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAG1C,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,6BAA6B;IAErD,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAQtD"}