@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/msg_validators/tx_validator/data_validator.ts

@@ -1,106 +1,173 @@
-import { MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
-import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
+import { computeContractClassId } from '@aztec/stdlib/contract';
+import { computeCalldataHash } from '@aztec/stdlib/hash';
+import {
+  TX_ERROR_CALLDATA_COUNT_MISMATCH,
+  TX_ERROR_CALLDATA_COUNT_TOO_LARGE,
+  TX_ERROR_CONTRACT_CLASS_LOGS,
+  TX_ERROR_CONTRACT_CLASS_LOG_COUNT,
+  TX_ERROR_CONTRACT_CLASS_LOG_LENGTH,
+  TX_ERROR_CONTRACT_CLASS_LOG_SORTING,
+  TX_ERROR_INCORRECT_CALLDATA,
+  TX_ERROR_INCORRECT_CONTRACT_CLASS_ID,
+  TX_ERROR_INCORRECT_HASH,
+  TX_ERROR_MALFORMED_CONTRACT_CLASS_LOG,
+  Tx,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export class DataTxValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:tx_data');
+  public readonly identifier: symbol = Symbol('DataTxValidator');
+
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('p2p:tx_validator:tx_data', bindings);
+  }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
-    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);
+    const reason =
+      (await this.#hasCorrectHash(tx)) ??
+      (await this.#hasCorrectCalldata(tx)) ??
+      (await this.#hasCorrectContractClassLogs(tx)) ??
+      (await this.#hasCorrectContractClassIds(tx));
+    return reason ? { result: 'invalid', reason: [reason] } : { result: 'valid' };
   }
 
-  async #hasCorrectExecutionRequests(tx: Tx): Promise<TxValidationResult> {
-    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}.`,
+  async #hasCorrectHash(tx: Tx): Promise<string | undefined> {
+    const expected = await Tx.computeTxHash(tx);
+    if (!tx.getTxHash().equals(expected)) {
+      const reason = TX_ERROR_INCORRECT_HASH;
+      this.#log.verbose(
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected hash ${expected.toString()}. Got ${tx
+          .getTxHash()
+          .toString()}.`,
       );
-      return { result: 'invalid', reason: ['Wrong number of execution requests for public calls'] };
+      return reason;
     }
+    return undefined;
+  }
 
-    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}`,
+  async #hasCorrectCalldata(tx: Tx): Promise<string | undefined> {
+    if (tx.publicFunctionCalldata.length !== tx.numberOfPublicCalls()) {
+      const reason = TX_ERROR_CALLDATA_COUNT_MISMATCH;
+      this.#log.verbose(
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${
+          tx.publicFunctionCalldata.length
+        }.`,
       );
-      return { result: 'invalid', reason: ['Too many args in total to enqueued public calls'] };
+      return reason;
     }
-    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}.`,
+
+    if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
+      const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
+      this.#log.verbose(
+        `Rejecting tx ${tx
+          .getTxHash()
+          .toString()}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
       );
-      return { result: 'invalid', reason: ['Incorrect execution request for public call'] };
+      return reason;
     }
 
-    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'] };
+    const callRequests = tx.getPublicCallRequestsWithCalldata();
+    for (let i = 0; i < callRequests.length; i++) {
+      const { request, calldata } = callRequests[i];
+      const hash = await computeCalldataHash(calldata);
+      if (!hash.equals(request.calldataHash)) {
+        const reason = TX_ERROR_INCORRECT_CALLDATA;
+        this.#log.verbose(`Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Call request index: ${i}.`);
+        return reason;
+      }
     }
 
-    return { result: 'valid' };
+    return undefined;
   }
 
-  async #hasCorrectContractClassLogs(tx: Tx): Promise<TxValidationResult> {
+  async #hasCorrectContractClassLogs(tx: Tx): Promise<string | undefined> {
     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 ${
+    if (contractClassLogsHashes.length !== tx.contractClassLogFields.length) {
+      this.#log.verbose(
+        `Rejecting tx ${tx.getTxHash().toString()} because of mismatched number of contract class logs. Expected ${
           contractClassLogsHashes.length
-        }. Got ${hashedContractClasslogs.length}.`,
+        }. Got ${tx.contractClassLogFields.length}.`,
       );
-      return { result: 'invalid', reason: ['Mismatched number of contract class logs'] };
+      return TX_ERROR_CONTRACT_CLASS_LOG_COUNT;
     }
+
+    const expectedHashes = await Promise.all(tx.contractClassLogFields.map(l => l.hash()));
     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.`,
+      const hash = expectedHashes[i];
+      if (!logHash.value.equals(hash)) {
+        if (expectedHashes.some(h => logHash.value.equals(h))) {
+          const matchingLogIndex = expectedHashes.findIndex(l => logHash.value.equals(l));
+          this.#log.verbose(
+            `Rejecting tx ${tx
+              .getTxHash()
+              .toString()} 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'] };
+          return TX_ERROR_CONTRACT_CLASS_LOG_SORTING;
         } else {
-          this.#log.warn(
-            `Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
+          this.#log.verbose(
+            `Rejecting tx ${tx.getTxHash().toString()} because of mismatched contract class logs. Expected hash ${
               logHash.value
-            } from the kernels. Got ${hashedLog} in the tx.`,
+            } from the kernels. Got ${hash} in the tx.`,
           );
-          return { result: 'invalid', reason: ['Mismatched contract class logs'] };
+          return TX_ERROR_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 ${
+
+      const expectedMinLength = 1 + tx.contractClassLogFields[i].fields.findLastIndex(f => !f.isZero());
+      if (logHash.logHash.length < expectedMinLength) {
+        this.#log.verbose(
+          `Rejecting tx ${tx
+            .getTxHash()
+            .toString()} because of incorrect contract class log length. Expected the length to be at least ${expectedMinLength}. Got ${
             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 TX_ERROR_CONTRACT_CLASS_LOG_LENGTH;
+      }
+    }
+
+    return undefined;
+  }
+
+  async #hasCorrectContractClassIds(tx: Tx): Promise<string | undefined> {
+    const contractClassLogs = tx.getContractClassLogs();
+    for (const log of contractClassLogs) {
+      if (!ContractClassPublishedEvent.isContractClassPublishedEvent(log)) {
+        continue;
+      }
+
+      let event;
+      try {
+        event = ContractClassPublishedEvent.fromLog(log);
+      } catch (e) {
+        this.#log.warn(`Rejecting tx ${tx.getTxHash()}: failed to parse contract class event: ${e}`);
+        return TX_ERROR_MALFORMED_CONTRACT_CLASS_LOG;
+      }
+
+      try {
+        const { publicBytecodeCommitment } = await event.toContractClassPublicWithBytecodeCommitment();
+        const computedClassId = await computeContractClassId({
+          artifactHash: event.artifactHash,
+          privateFunctionsRoot: event.privateFunctionsRoot,
+          publicBytecodeCommitment,
+        });
+        if (!computedClassId.equals(event.contractClassId)) {
+          this.#log.warn(
+            `Rejecting tx ${tx.getTxHash()}: contract class id mismatch. Claimed ${event.contractClassId}, computed ${computedClassId}`,
+          );
+          return TX_ERROR_INCORRECT_CONTRACT_CLASS_ID;
+        }
+      } catch (e) {
+        this.#log.warn(`Rejecting tx ${tx.getTxHash()}: failed to compute contract class id: ${e}`);
+        return TX_ERROR_MALFORMED_CONTRACT_CLASS_LOG;
       }
     }
-    return { result: 'valid' };
+    return undefined;
   }
 }

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -1,38 +1,46 @@
-import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, Tx, type TxValidationResult, type TxValidator, hasPublicCalls } from '@aztec/stdlib/tx';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import {
+  TX_ERROR_DUPLICATE_NULLIFIER_IN_TX,
+  TX_ERROR_EXISTING_NULLIFIER,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export interface NullifierSource {
   nullifiersExist: (nullifiers: Buffer[]) => Promise<boolean[]>;
 }
 
-export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_double_spend');
+/** Structural interface for double-spend validation. */
+export interface HasNullifierData {
+  txHash: { toString(): string };
+  data: { getNonEmptyNullifiers(): Fr[] };
+}
+
+export class DoubleSpendTxValidator<T extends HasNullifierData> implements TxValidator<T> {
+  #log: Logger;
   #nullifierSource: NullifierSource;
 
-  constructor(nullifierSource: NullifierSource) {
+  constructor(nullifierSource: NullifierSource, bindings?: LoggerBindings) {
     this.#nullifierSource = nullifierSource;
+    this.#log = createLogger('p2p:tx_validator:tx_double_spend', bindings);
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    // 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'] };
-      }
+    const nullifiers = tx.data.getNonEmptyNullifiers();
+
+    // Ditch this tx if it has repeated nullifiers
+    const uniqueNullifiers = new Set(nullifiers.map(n => n.toBigInt()));
+    if (uniqueNullifiers.size !== nullifiers.length) {
+      this.#log.verbose(`Rejecting tx ${tx.txHash} for emitting duplicate nullifiers`);
+      return { result: 'invalid', reason: [TX_ERROR_DUPLICATE_NULLIFIER_IN_TX] };
     }
+
+    if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
+      this.#log.verbose(`Rejecting tx ${tx.txHash} for repeating a nullifier`);
+      return { result: 'invalid', reason: [TX_ERROR_EXISTING_NULLIFIER] };
+    }
+
     return { result: 'valid' };
   }
 }