@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.24de95ac

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

@@ -1 +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"}
+{"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,EACL,KAAK,KAAK,EAKV,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,mBAAmB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAIvE,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE;QACd,SAAS,EAAE,EAAE,CAAC;QACd,aAAa,EAAE,EAAE,CAAC;QAClB,UAAU,EAAE,EAAE,CAAC;QACf,qBAAqB,EAAE,EAAE,CAAC;KAC3B;IAGH,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CA4D/C"}

package/dest/msg_validators/tx_validator/metadata_validator.js

@@ -1,41 +1,60 @@
 import { createLogger } from '@aztec/foundation/log';
-import { Tx } from '@aztec/stdlib/tx';
+import { TX_ERROR_INCORRECT_L1_CHAIN_ID, TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH, TX_ERROR_INCORRECT_ROLLUP_VERSION, TX_ERROR_INCORRECT_VK_TREE_ROOT } from '@aztec/stdlib/tx';
 export class MetadataTxValidator {
-    chainId;
-    blockNumber;
+    values;
     #log;
-    constructor(chainId, blockNumber){
-        this.chainId = chainId;
-        this.blockNumber = blockNumber;
+    constructor(values){
+        this.values = values;
         this.#log = createLogger('p2p:tx_validator:tx_metadata');
     }
-    async validateTx(tx) {
+    validateTx(tx) {
         const errors = [];
-        if (!await this.#hasCorrectChainId(tx)) {
-            errors.push('Incorrect chain id');
+        if (!this.#hasCorrectL1ChainId(tx)) {
+            errors.push(TX_ERROR_INCORRECT_L1_CHAIN_ID);
         }
-        if (!await this.#isValidForBlockNumber(tx)) {
-            errors.push('Invalid block number');
+        if (!this.#hasCorrectRollupVersion(tx)) {
+            errors.push(TX_ERROR_INCORRECT_ROLLUP_VERSION);
         }
-        return errors.length > 0 ? {
+        if (!this.#hasCorrectVkTreeRoot(tx)) {
+            errors.push(TX_ERROR_INCORRECT_VK_TREE_ROOT);
+        }
+        if (!this.#hasCorrectprotocolContractsHash(tx)) {
+            errors.push(TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH);
+        }
+        return Promise.resolve(errors.length > 0 ? {
             result: 'invalid',
             reason: errors
         } : {
             result: 'valid'
-        };
+        });
+    }
+    #hasCorrectVkTreeRoot(tx) {
+        // This gets implicitly tested in the proof validator, but we can get a much cheaper check here by looking early at the vk.
+        if (!tx.data.constants.vkTreeRoot.equals(this.values.vkTreeRoot)) {
+            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`);
+            return false;
+        } else {
+            return true;
+        }
+    }
+    #hasCorrectprotocolContractsHash(tx) {
+        if (!tx.data.constants.protocolContractsHash.equals(this.values.protocolContractsHash)) {
+            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect protocol contracts hash ${tx.data.constants.protocolContractsHash.toString()} != ${this.values.protocolContractsHash.toString()}`);
+            return false;
+        }
+        return true;
     }
-    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()}`);
+    #hasCorrectL1ChainId(tx) {
+        if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
+            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.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}.`);
+    #hasCorrectRollupVersion(tx) {
+        if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
+            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`);
             return false;
         } else {
             return true;

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

@@ -0,0 +1,14 @@
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+export declare class PhasesTxValidator implements TxValidator<Tx> {
+    #private;
+    private setupAllowList;
+    private timestamp;
+    private contractsDB;
+    constructor(contracts: ContractDataSource, setupAllowList: AllowedElement[], timestamp: UInt64);
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+    private isOnAllowList;
+}
+//# sourceMappingURL=phases_validator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"phases_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/phases_validator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAIL,EAAE,EAEF,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,qBAAa,iBAAkB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAMrD,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,SAAS;IALnB,OAAO,CAAC,WAAW,CAAoB;gBAGrC,SAAS,EAAE,kBAAkB,EACrB,cAAc,EAAE,cAAc,EAAE,EAChC,SAAS,EAAE,MAAM;IAKrB,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;YAqCvC,aAAa;CAiD5B"}

package/dest/msg_validators/tx_validator/phases_validator.js

@@ -0,0 +1,91 @@
+import { createLogger } from '@aztec/foundation/log';
+import { PublicContractsDB, getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import { TX_ERROR_DURING_VALIDATION, TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED, TxExecutionPhase } from '@aztec/stdlib/tx';
+export class PhasesTxValidator {
+    setupAllowList;
+    timestamp;
+    #log;
+    contractsDB;
+    constructor(contracts, setupAllowList, timestamp){
+        this.setupAllowList = setupAllowList;
+        this.timestamp = timestamp;
+        this.#log = createLogger('sequencer:tx_validator:tx_phases');
+        this.contractsDB = new PublicContractsDB(contracts);
+    }
+    async validateTx(tx) {
+        try {
+            // TODO(@spalladino): We add this just to handle public authwit-check calls during setup
+            // which are needed for public FPC flows, but fail if the account contract hasnt been deployed yet,
+            // which is what we're trying to do as part of the current txs.
+            await this.contractsDB.addNewContracts(tx);
+            if (!tx.data.forPublic) {
+                this.#log.debug(`Tx ${tx.getTxHash().toString()} does not contain enqueued public functions. Skipping phases validation.`);
+                return {
+                    result: 'valid'
+                };
+            }
+            const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+            for (const setupFn of setupFns){
+                if (!await this.isOnAllowList(setupFn, this.setupAllowList)) {
+                    this.#log.verbose(`Rejecting tx ${tx.getTxHash().toString()} because it calls setup function not on allow list: ${setupFn.request.contractAddress}:${setupFn.functionSelector}`, {
+                        allowList: this.setupAllowList
+                    });
+                    return {
+                        result: 'invalid',
+                        reason: [
+                            TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED
+                        ]
+                    };
+                }
+            }
+            return {
+                result: 'valid'
+            };
+        } catch (err) {
+            this.#log.error(`Error validating phases for tx`, err);
+            return {
+                result: 'invalid',
+                reason: [
+                    TX_ERROR_DURING_VALIDATION
+                ]
+            };
+        } finally{
+            this.contractsDB.clearContractsForTx();
+        }
+    }
+    async isOnAllowList(publicCall, allowList) {
+        if (publicCall.isEmpty()) {
+            return true;
+        }
+        const contractAddress = publicCall.request.contractAddress;
+        const functionSelector = publicCall.functionSelector;
+        // do these checks first since they don't require the contract class
+        for (const entry of allowList){
+            if ('address' in entry && !('selector' in entry)) {
+                if (contractAddress.equals(entry.address)) {
+                    return true;
+                }
+            }
+            if ('address' in entry && 'selector' in entry) {
+                if (contractAddress.equals(entry.address) && entry.selector.equals(functionSelector)) {
+                    return true;
+                }
+            }
+            const contractClass = await this.contractsDB.getContractInstance(contractAddress, this.timestamp);
+            if (!contractClass) {
+                throw new Error(`Contract not found: ${contractAddress}`);
+            }
+            if ('classId' in entry && !('selector' in entry)) {
+                if (contractClass.currentContractClassId.equals(entry.classId)) {
+                    return true;
+                }
+            }
+            if ('classId' in entry && 'selector' in entry) {
+                if (contractClass.currentContractClassId.equals(entry.classId) && (entry.selector === undefined || entry.selector.equals(functionSelector))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type Tx } from '@aztec/stdlib/tx';
+export declare function patchNonRevertibleFn(tx: Tx, index: number, overrides: {
+    address?: AztecAddress;
+    selector: FunctionSelector;
+    args?: Fr[];
+    msgSender?: AztecAddress;
+}): Promise<AztecAddress>;
+export declare function patchRevertibleFn(tx: Tx, index: number, overrides: {
+    address?: AztecAddress;
+    selector: FunctionSelector;
+    args?: Fr[];
+    msgSender?: AztecAddress;
+}): Promise<AztecAddress>;
+//# sourceMappingURL=test_utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/test_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAgB,KAAK,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAEzD,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,OAAO,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAC;IAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,YAAY,CAAA;CAAE,GACvG,OAAO,CAAC,YAAY,CAAC,CAEvB;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,OAAO,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAC;IAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,YAAY,CAAA;CAAE,GACvG,OAAO,CAAC,YAAY,CAAC,CAEvB"}

package/dest/msg_validators/tx_validator/test_utils.js

@@ -0,0 +1,22 @@
+import { HashedValues } from '@aztec/stdlib/tx';
+export function patchNonRevertibleFn(tx, index, overrides) {
+    return patchFn('nonRevertibleAccumulatedData', tx, index, overrides);
+}
+export function patchRevertibleFn(tx, index, overrides) {
+    return patchFn('revertibleAccumulatedData', tx, index, overrides);
+}
+async function patchFn(where, tx, index, overrides) {
+    const calldataIndex = where === 'nonRevertibleAccumulatedData' ? index : index + tx.data.forPublic.nonRevertibleAccumulatedData.publicCallRequests.length;
+    const calldata = [
+        overrides.selector.toField(),
+        ...overrides.args ?? []
+    ];
+    const hashedCalldata = await HashedValues.fromCalldata(calldata);
+    tx.publicFunctionCalldata[calldataIndex] = hashedCalldata;
+    const request = tx.data.forPublic[where].publicCallRequests[index];
+    request.contractAddress = overrides.address ?? request.contractAddress;
+    request.msgSender = overrides.msgSender ?? request.msgSender;
+    request.calldataHash = hashedCalldata.hash;
+    tx.data.forPublic[where].publicCallRequests[index] = request;
+    return request.contractAddress;
+}

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

@@ -0,0 +1,12 @@
+import { type AnyTx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+export declare class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
+    #private;
+    private values;
+    constructor(values: {
+        timestamp: UInt64;
+        blockNumber: number;
+    });
+    validateTx(tx: T): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=timestamp_validator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/timestamp_validator.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,KAAK,EAEV,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAEjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,qBAAa,oBAAoB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAIxE,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE;QAGd,SAAS,EAAE,MAAM,CAAC;QAElB,WAAW,EAAE,MAAM,CAAC;KACrB;IAGH,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAsB/C"}

package/dest/msg_validators/tx_validator/timestamp_validator.js

@@ -0,0 +1,32 @@
+import { createLogger } from '@aztec/foundation/log';
+import { TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP, getTxHash } from '@aztec/stdlib/tx';
+export class TimestampTxValidator {
+    values;
+    #log;
+    constructor(values){
+        this.values = values;
+        this.#log = createLogger('p2p:tx_validator:timestamp');
+    }
+    validateTx(tx) {
+        const includeByTimestamp = tx.data.includeByTimestamp;
+        // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
+        // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
+        const buildingBlock1 = this.values.blockNumber === 1;
+        if (!buildingBlock1 && includeByTimestamp < this.values.timestamp) {
+            if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber === 0) {
+                this.#log.warn(`A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`);
+            }
+            this.#log.verbose(`Rejecting tx ${getTxHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${this.values.timestamp}.`);
+            return Promise.resolve({
+                result: 'invalid',
+                reason: [
+                    TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP
+                ]
+            });
+        } else {
+            return Promise.resolve({
+                result: 'valid'
+            });
+        }
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx_permitted_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/tx_permitted_validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE5E,qBAAa,oBAAqB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAG9C,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,OAAO;IAEtC,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAQhD"}

package/dest/msg_validators/tx_validator/tx_permitted_validator.js

@@ -0,0 +1,24 @@
+import { createLogger } from '@aztec/foundation/log';
+export class TxPermittedValidator {
+    permitted;
+    #log;
+    constructor(permitted){
+        this.permitted = permitted;
+        this.#log = createLogger('p2p:tx_validator:tx_permitted');
+    }
+    validateTx(tx) {
+        if (!this.permitted) {
+            const txHash = tx.getTxHash();
+            this.#log.verbose(`Rejecting tx ${txHash.toString()}. Reason: Transactions are not permitted`);
+            return Promise.resolve({
+                result: 'invalid',
+                reason: [
+                    'Transactions are not permitted'
+                ]
+            });
+        }
+        return Promise.resolve({
+            result: 'valid'
+        });
+    }
+}

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

@@ -1 +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"}
+{"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,EAA0B,EAAE,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEzG,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;CAStD"}

package/dest/msg_validators/tx_validator/tx_proof_validator.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import { Tx } from '@aztec/stdlib/tx';
+import { TX_ERROR_INVALID_PROOF } from '@aztec/stdlib/tx';
 export class TxProofValidator {
     verifier;
     #log;
@@ -8,16 +8,17 @@ export class TxProofValidator {
         this.#log = createLogger('p2p:tx_validator:private_proof');
     }
     async validateTx(tx) {
-        if (!await this.verifier.verifyProof(tx)) {
-            this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for invalid proof`);
+        const result = await this.verifier.verifyProof(tx);
+        if (!result.valid) {
+            this.#log.verbose(`Rejecting tx ${tx.getTxHash().toString()} for invalid proof`);
             return {
                 result: 'invalid',
                 reason: [
-                    'Invalid proof'
+                    TX_ERROR_INVALID_PROOF
                 ]
             };
         }
-        this.#log.trace(`Accepted ${Tx.getHash(tx)} with valid proof`);
+        this.#log.trace(`Accepted ${tx.getTxHash().toString()} with valid proof`);
         return {
             result: 'valid'
         };

package/dest/services/discv5/discV5_service.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
 import { type TelemetryClient } from '@aztec/telemetry-client';
-import { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import { type IDiscv5CreateOptions } from '@nethermindeth/discv5';
+import { ENR } from '@nethermindeth/enr';
 import EventEmitter from 'events';
 import type { P2PConfig } from '../../config.js';
 import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
@@ -11,6 +11,7 @@ import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
 export declare class DiscV5Service extends EventEmitter implements PeerDiscoveryService {
     private peerId;
     private config;
+    private readonly packageVersion;
     private logger;
     /** The Discv5 instance */
     private discv5;
@@ -18,17 +19,17 @@ export declare class DiscV5Service extends EventEmitter implements PeerDiscovery
     private enr;
     /** Version identifiers. */
     private versions;
-    /** UDP listen addr */
-    private listenMultiAddrUdp;
     private currentState;
-    readonly bootstrapNodes: string[];
     private bootstrapNodePeerIds;
-    private bootstrapNodeEnrs;
+    bootstrapNodeEnrs: ENR[];
+    private trustedPeerEnrs;
     private startTime;
-    constructor(peerId: PeerId, config: P2PConfig, telemetry?: TelemetryClient, logger?: import("@aztec/foundation/log").Logger);
+    private handlers;
+    constructor(peerId: PeerId, config: P2PConfig, packageVersion: string, telemetry?: TelemetryClient, logger?: import("@aztec/foundation/log").Logger, configOverrides?: Partial<IDiscv5CreateOptions>);
+    private onMultiaddrUpdated;
     start(): Promise<void>;
     runRandomNodesQuery(): Promise<void>;
-    getAllPeers(): ENR[];
+    getKadValues(): ENR[];
     getEnr(): ENR;
     getPeerId(): PeerId;
     getStatus(): PeerDiscoveryState;

package/dest/services/discv5/discV5_service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discV5_service.d.ts","sourceRoot":"","sources":["../../../src/services/discv5/discV5_service.ts"],"names":[],"mappings":";AAGA,OAAO,EAAsB,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAGvG,OAAO,EAAE,GAAG,EAAe,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD,OAAO,EAAE,KAAK,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAI9E;;GAEG;AACH,qBAAa,aAAc,SAAQ,YAAa,YAAW,oBAAoB;IAsB3E,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,MAAM;IAxBhB,0BAA0B;IAC1B,OAAO,CAAC,MAAM,CAA8B;IAE5C,0BAA0B;IAC1B,OAAO,CAAC,GAAG,CAAc;IAEzB,2BAA2B;IAC3B,OAAO,CAAC,QAAQ,CAAqB;IAErC,sBAAsB;IACtB,OAAO,CAAC,kBAAkB,CAAY;IAEtC,OAAO,CAAC,YAAY,CAA8B;IAElD,SAAgB,cAAc,EAAE,MAAM,EAAE,CAAM;IAC9C,OAAO,CAAC,oBAAoB,CAAgB;IAC5C,OAAO,CAAC,iBAAiB,CAAa;IAEtC,OAAO,CAAC,SAAS,CAAK;gBAGZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,EACzB,SAAS,GAAE,eAAsC,EACzC,MAAM,yCAAqC;IA+DxC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuCtB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB1C,WAAW,IAAI,GAAG,EAAE;IAIpB,MAAM,IAAI,GAAG;IAIb,SAAS,IAAI,MAAM;IAInB,SAAS,IAAI,kBAAkB;IAI/B,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YASpB,UAAU;IAOxB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,WAAW;CA0BpB"}
+{"version":3,"file":"discV5_service.d.ts","sourceRoot":"","sources":["../../../src/services/discv5/discV5_service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEvG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAmC,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AACnG,OAAO,EAAE,GAAG,EAAe,MAAM,oBAAoB,CAAC;AACtD,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD,OAAO,EAAE,KAAK,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAI9E;;GAEG;AACH,qBAAa,aAAc,SAAQ,YAAa,YAAW,oBAAoB;IAyB3E,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,MAAM;IA5BhB,0BAA0B;IAC1B,OAAO,CAAC,MAAM,CAAqB;IAEnC,0BAA0B;IAC1B,OAAO,CAAC,GAAG,CAAc;IAEzB,2BAA2B;IAC3B,OAAO,CAAC,QAAQ,CAAqB;IAErC,OAAO,CAAC,YAAY,CAA8B;IAElD,OAAO,CAAC,oBAAoB,CAAgB;IACrC,iBAAiB,EAAE,GAAG,EAAE,CAAM;IACrC,OAAO,CAAC,eAAe,CAAa;IAEpC,OAAO,CAAC,SAAS,CAAK;IAEtB,OAAO,CAAC,QAAQ,CAId;gBAGQ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,EACR,cAAc,EAAE,MAAM,EACvC,SAAS,GAAE,eAAsC,EACzC,MAAM,yCAAqC,EACnD,eAAe,GAAE,OAAO,CAAC,oBAAoB,CAAM;IA4ErD,OAAO,CAAC,kBAAkB;IAQb,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuDtB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB1C,YAAY,IAAI,GAAG,EAAE;IAIrB,MAAM,IAAI,GAAG;IAIb,SAAS,IAAI,MAAM;IAInB,SAAS,IAAI,kBAAkB;IAI/B,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAapB,UAAU;IAOxB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,WAAW;CA0BpB"}

package/dest/services/discv5/discV5_service.js

@@ -2,13 +2,13 @@ import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { checkCompressedComponentVersion } from '@aztec/stdlib/versioning';
 import { OtelMetricsAdapter, getTelemetryClient } from '@aztec/telemetry-client';
-import { Discv5 } from '@chainsafe/discv5';
-import { ENR, SignableENR } from '@chainsafe/enr';
 import { multiaddr } from '@multiformats/multiaddr';
+import { Discv5 } from '@nethermindeth/discv5';
+import { ENR } from '@nethermindeth/enr';
 import EventEmitter from 'events';
+import { createNodeENR } from '../../enr/generate-enr.js';
 import { AZTEC_ENR_KEY, Discv5Event, PeerEvent } from '../../types/index.js';
 import { convertToMultiaddr } from '../../util.js';
-import { setAztecEnrKey } from '../../versioning.js';
 import { PeerDiscoveryState } from '../service.js';
 const delayBeforeStart = 2000; // 2sec
 /**
@@ -16,46 +16,52 @@ const delayBeforeStart = 2000; // 2sec
  */ export class DiscV5Service extends EventEmitter {
     peerId;
     config;
+    packageVersion;
     logger;
     /** The Discv5 instance */ discv5;
     /** This instance's ENR */ enr;
     /** Version identifiers. */ versions;
-    /** UDP listen addr */ listenMultiAddrUdp;
     currentState;
-    bootstrapNodes;
     bootstrapNodePeerIds;
     bootstrapNodeEnrs;
+    trustedPeerEnrs;
     startTime;
-    constructor(peerId, config, telemetry = getTelemetryClient(), logger = createLogger('p2p:discv5_service')){
-        super(), this.peerId = peerId, this.config = config, this.logger = logger, this.currentState = PeerDiscoveryState.STOPPED, this.bootstrapNodes = [], this.bootstrapNodePeerIds = [], this.bootstrapNodeEnrs = [], this.startTime = 0;
-        const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
-        this.bootstrapNodes = bootstrapNodes ?? [];
-        this.bootstrapNodeEnrs = this.bootstrapNodes.map((x)=>ENR.decodeTxt(x));
-        // create ENR from PeerId
-        this.enr = SignableENR.createFromPeerId(peerId);
-        // Add aztec identification to ENR
-        this.versions = setAztecEnrKey(this.enr, config);
-        if (!tcpAnnounceAddress) {
-            throw new Error('You need to provide at least a TCP announce address.');
+    handlers;
+    constructor(peerId, config, packageVersion, telemetry = getTelemetryClient(), logger = createLogger('p2p:discv5_service'), configOverrides = {}){
+        super(), this.peerId = peerId, this.config = config, this.packageVersion = packageVersion, this.logger = logger, this.currentState = PeerDiscoveryState.STOPPED, this.bootstrapNodePeerIds = [], this.bootstrapNodeEnrs = [], this.trustedPeerEnrs = [], this.startTime = 0, this.handlers = {
+            onMultiaddrUpdated: this.onMultiaddrUpdated.bind(this),
+            onDiscovered: this.onDiscovered.bind(this),
+            onEnrAdded: this.onEnrAdded.bind(this)
+        };
+        const { p2pIp, p2pPort, p2pBroadcastPort, bootstrapNodes, trustedPeers, privatePeers } = config;
+        this.bootstrapNodeEnrs = bootstrapNodes.map((x)=>ENR.decodeTxt(x));
+        const privatePeerEnrs = new Set(privatePeers);
+        this.trustedPeerEnrs = trustedPeers.filter((x)=>!privatePeerEnrs.has(x)).map((x)=>ENR.decodeTxt(x));
+        // If no overridden broadcast port is provided, use the p2p port as the broadcast port
+        if (!p2pBroadcastPort) {
+            this.logger.warn('No p2pBroadcastPort provided, using p2pPort as broadcast port');
+            config.p2pBroadcastPort = p2pPort;
         }
-        const multiAddrTcp = multiaddr(`${convertToMultiaddr(tcpAnnounceAddress, 'tcp')}/p2p/${peerId.toString()}`);
-        // if no udp announce address is provided, use the tcp announce address
-        const multiAddrUdp = multiaddr(`${convertToMultiaddr(udpAnnounceAddress || tcpAnnounceAddress, 'udp')}/p2p/${peerId.toString()}`);
-        this.listenMultiAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
-        // set location multiaddr in ENR record
-        this.enr.setLocationMultiaddr(multiAddrUdp);
-        this.enr.setLocationMultiaddr(multiAddrTcp);
+        const bindAddrs = {
+            ip4: multiaddr(convertToMultiaddr(config.listenAddress, p2pPort, 'udp'))
+        };
+        let multiAddrUdp, multiAddrTcp;
+        if (p2pIp) {
+            multiAddrTcp = multiaddr(`${convertToMultiaddr(p2pIp, config.p2pBroadcastPort, 'tcp')}/p2p/${peerId.toString()}`);
+            multiAddrUdp = multiaddr(`${convertToMultiaddr(p2pIp, config.p2pBroadcastPort, 'udp')}/p2p/${peerId.toString()}`);
+        }
+        ({ enr: this.enr, versions: this.versions } = createNodeENR(peerId, multiAddrUdp, multiAddrTcp, config, this.packageVersion));
         const metricsRegistry = new OtelMetricsAdapter(telemetry);
         this.discv5 = Discv5.create({
             enr: this.enr,
             peerId,
-            bindAddrs: {
-                ip4: this.listenMultiAddrUdp
-            },
+            bindAddrs,
             config: {
                 lookupTimeout: 2000,
                 requestTimeout: 2000,
-                allowUnverifiedSessions: true
+                allowUnverifiedSessions: true,
+                enrUpdate: !p2pIp ? true : false,
+                ...configOverrides.config
             },
             metricsRegistry
         });
@@ -77,8 +83,18 @@ const delayBeforeStart = 2000; // 2sec
                 return origOnEstablished(...args);
             }
         };
-        this.discv5.on(Discv5Event.DISCOVERED, this.onDiscovered.bind(this));
-        this.discv5.on(Discv5Event.ENR_ADDED, this.onEnrAdded.bind(this));
+        this.discv5.on(Discv5Event.DISCOVERED, this.handlers.onDiscovered);
+        this.discv5.on(Discv5Event.ENR_ADDED, this.handlers.onEnrAdded);
+        this.discv5.on(Discv5Event.MULTIADDR_UPDATED, this.handlers.onMultiaddrUpdated);
+    }
+    onMultiaddrUpdated(m) {
+        // We want to update our tcp port to match the udp port
+        // p2pBroadcastPort is optional on config, however it is set to default within the p2p client factory
+        const multiAddrTcp = multiaddr(convertToMultiaddr(m.nodeAddress().address, this.config.p2pBroadcastPort, 'tcp'));
+        this.enr.setLocationMultiaddr(multiAddrTcp);
+        this.logger.info('Multiaddr updated', {
+            multiaddr: multiAddrTcp.toString()
+        });
     }
     async start() {
         if (this.currentState === PeerDiscoveryState.RUNNING) {
@@ -96,10 +112,10 @@ const delayBeforeStart = 2000; // 2sec
         });
         this.currentState = PeerDiscoveryState.RUNNING;
         // Add bootnode ENR if provided
-        if (this.bootstrapNodes?.length) {
+        if (this.bootstrapNodeEnrs?.length) {
             // Do this conversion once since it involves an async function call
             this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodeEnrs.map((enr)=>enr.peerId()));
-            this.logger.info(`Adding ${this.bootstrapNodes} bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
+            this.logger.info(`Adding ${this.bootstrapNodeEnrs.length} bootstrap nodes ENRs: ${this.bootstrapNodeEnrs.map((enr)=>enr.encodeTxt()).join(', ')}`);
             for (const enr of this.bootstrapNodeEnrs){
                 try {
                     if (this.config.bootstrapNodeEnrVersionCheck) {
@@ -115,10 +131,17 @@ const delayBeforeStart = 2000; // 2sec
                 }
             }
         }
+        // Add trusted peer ENRs if provided
+        if (this.trustedPeerEnrs?.length) {
+            this.logger.info(`Adding ${this.trustedPeerEnrs.length} trusted peer ENRs: ${this.trustedPeerEnrs.map((enr)=>enr.encodeTxt()).join(', ')}`);
+            for (const enr of this.trustedPeerEnrs){
+                this.discv5.addEnr(enr);
+            }
+        }
     }
     async runRandomNodesQuery() {
         if (this.currentState !== PeerDiscoveryState.RUNNING) {
-            throw new Error('DiscV5Service not running');
+            return;
         }
         // First, wait some time before starting the peer discovery
         // reference: https://github.com/ChainSafe/lodestar/issues/3423
@@ -132,7 +155,7 @@ const delayBeforeStart = 2000; // 2sec
             this.logger.error(`Error running discV5 random node query: ${err}`);
         }
     }
-    getAllPeers() {
+    getKadValues() {
         return this.discv5.kadValues();
     }
     getEnr() {
@@ -148,8 +171,12 @@ const delayBeforeStart = 2000; // 2sec
         return this.bootstrapNodePeerIds.some((node)=>node.equals(peerId));
     }
     async stop() {
-        await this.discv5.off(Discv5Event.DISCOVERED, this.onDiscovered);
-        await this.discv5.off(Discv5Event.ENR_ADDED, this.onEnrAdded);
+        if (this.currentState !== PeerDiscoveryState.RUNNING) {
+            return;
+        }
+        await this.discv5.off(Discv5Event.DISCOVERED, this.handlers.onDiscovered);
+        await this.discv5.off(Discv5Event.ENR_ADDED, this.handlers.onEnrAdded);
+        await this.discv5.off(Discv5Event.MULTIADDR_UPDATED, this.handlers.onMultiaddrUpdated);
         await this.discv5.stop();
         this.currentState = PeerDiscoveryState.STOPPED;
     }
@@ -190,7 +217,7 @@ const delayBeforeStart = 2000; // 2sec
         // Check the peer is an aztec peer
         const value = enr.kvs.get(AZTEC_ENR_KEY);
         if (!value) {
-            this.logger.warn(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
+            this.logger.debug(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
             return false;
         }
         // And check it has the correct version