@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/tx/tx_effect.ts

@@ -1,6 +1,5 @@
 import {
   CONTRACT_CLASS_LOGS_PREFIX,
-  CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
   L2_L1_MSGS_PREFIX,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
@@ -11,17 +10,13 @@ import {
   NOTES_PREFIX,
   NULLIFIERS_PREFIX,
   PRIVATE_LOGS_PREFIX,
-  PRIVATE_LOG_SIZE_IN_FIELDS,
   PUBLIC_DATA_UPDATE_REQUESTS_PREFIX,
   PUBLIC_LOGS_PREFIX,
-  PUBLIC_LOG_SIZE_IN_FIELDS,
   REVERT_CODE_PREFIX,
   TX_FEE_PREFIX,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple, makeTupleAsync } from '@aztec/foundation/array';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { sha256Trunc } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import {
@@ -31,6 +26,7 @@ import {
   serializeToBuffer,
 } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -158,6 +154,28 @@ export class TxEffect {
     ]);
   }
 
+  equals(other: TxEffect): boolean {
+    return (
+      this.revertCode.equals(other.revertCode) &&
+      this.txHash.equals(other.txHash) &&
+      this.transactionFee.equals(other.transactionFee) &&
+      this.noteHashes.length === other.noteHashes.length &&
+      this.noteHashes.every((h, i) => h.equals(other.noteHashes[i])) &&
+      this.nullifiers.length === other.nullifiers.length &&
+      this.nullifiers.every((h, i) => h.equals(other.nullifiers[i])) &&
+      this.l2ToL1Msgs.length === other.l2ToL1Msgs.length &&
+      this.l2ToL1Msgs.every((h, i) => h.equals(other.l2ToL1Msgs[i])) &&
+      this.publicDataWrites.length === other.publicDataWrites.length &&
+      this.publicDataWrites.every((h, i) => h.equals(other.publicDataWrites[i])) &&
+      this.privateLogs.length === other.privateLogs.length &&
+      this.privateLogs.every((h, i) => h.equals(other.privateLogs[i])) &&
+      this.publicLogs.length === other.publicLogs.length &&
+      this.publicLogs.every((h, i) => h.equals(other.publicLogs[i])) &&
+      this.contractClassLogs.length === other.contractClassLogs.length &&
+      this.contractClassLogs.every((h, i) => h.equals(other.contractClassLogs[i]))
+    );
+  }
+
   /** Returns the size of this tx effect in bytes as serialized onto DA. */
   getDASize() {
     return this.toBlobFields().length * Fr.SIZE_IN_BYTES;
@@ -187,43 +205,46 @@ export class TxEffect {
 
   /**
    * Computes txOutHash of this tx effect.
-   * TODO(#7218): Revert to fixed height tree for outbox
-   * @dev Follows new_sha in variable_merkle_tree.nr
+   * @dev Follows new_sha in unbalanced_merkle_tree.nr
    */
-  txOutHash() {
+  txOutHash(): Buffer {
     const { l2ToL1Msgs } = this;
     if (l2ToL1Msgs.length == 0) {
       return Buffer.alloc(32);
     }
-    const depth = l2ToL1Msgs.length == 1 ? 1 : Math.ceil(Math.log2(l2ToL1Msgs.length));
-    let thisLayer = padArrayEnd(
-      l2ToL1Msgs.map(msg => msg.toBuffer()),
-      Buffer.alloc(32),
-      2 ** depth,
-    );
-    let nextLayer = [];
-    for (let i = 0; i < depth; i++) {
-      for (let j = 0; j < thisLayer.length; j += 2) {
-        // Store the hash of each pair one layer up
-        nextLayer[j / 2] = sha256Trunc(Buffer.concat([thisLayer[j], thisLayer[j + 1]]));
-      }
-      thisLayer = nextLayer;
-      nextLayer = [];
-    }
-    return thisLayer[0];
+
+    return computeUnbalancedMerkleTreeRoot(l2ToL1Msgs.map(msg => msg.toBuffer()));
   }
 
-  static async random(numPublicCallsPerTx = 3, numPublicLogsPerCall = 1): Promise<TxEffect> {
+  static async random(
+    numPublicCallsPerTx = 3,
+    numPublicLogsPerCall = 1,
+    maxEffects: number | undefined = undefined,
+  ): Promise<TxEffect> {
     return new TxEffect(
       RevertCode.random(),
       TxHash.random(),
       new Fr(Math.floor(Math.random() * 100_000)),
-      makeTuple(MAX_NOTE_HASHES_PER_TX, Fr.random),
-      makeTuple(MAX_NULLIFIERS_PER_TX, Fr.random),
-      makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, Fr.random),
-      makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, () => new PublicDataWrite(Fr.random(), Fr.random())),
-      makeTuple(MAX_PRIVATE_LOGS_PER_TX, () => new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random))),
-      await makeTupleAsync(numPublicCallsPerTx * numPublicLogsPerCall, PublicLog.random),
+      makeTuple(
+        maxEffects === undefined ? MAX_NOTE_HASHES_PER_TX : Math.min(maxEffects, MAX_NOTE_HASHES_PER_TX),
+        Fr.random,
+      ),
+      makeTuple(
+        maxEffects === undefined ? MAX_NULLIFIERS_PER_TX : Math.min(maxEffects, MAX_NULLIFIERS_PER_TX),
+        Fr.random,
+      ),
+      makeTuple(
+        maxEffects === undefined ? MAX_L2_TO_L1_MSGS_PER_TX : Math.min(maxEffects, MAX_L2_TO_L1_MSGS_PER_TX),
+        Fr.random,
+      ),
+      makeTuple(
+        maxEffects === undefined
+          ? MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+          : Math.min(maxEffects, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX),
+        PublicDataWrite.random,
+      ),
+      makeTuple(MAX_PRIVATE_LOGS_PER_TX, () => PrivateLog.random()),
+      await makeTupleAsync(numPublicCallsPerTx * numPublicLogsPerCall, async () => await PublicLog.random()),
       await makeTupleAsync(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.random),
     );
   }
@@ -350,41 +371,20 @@ export class TxEffect {
       flattened.push(...this.l2ToL1Msgs);
     }
     if (this.publicDataWrites.length) {
-      flattened.push(this.toPrefix(PUBLIC_DATA_UPDATE_REQUESTS_PREFIX, this.publicDataWrites.length * 2));
-      flattened.push(...this.publicDataWrites.map(w => [w.leafSlot, w.value]).flat());
+      flattened.push(this.toPrefix(PUBLIC_DATA_UPDATE_REQUESTS_PREFIX, this.publicDataWrites.length));
+      flattened.push(...this.publicDataWrites.flatMap(w => w.toBlobFields()));
     }
     if (this.privateLogs.length) {
-      const totalLogLen = this.privateLogs.reduce(
-        // +1 for length prefix
-        (total, log) => total + (log.getEmittedLength() == 0 ? 0 : log.getEmittedLength() + 1),
-        0,
-      );
-      flattened.push(this.toPrefix(PRIVATE_LOGS_PREFIX, totalLogLen));
-      flattened.push(...this.privateLogs.flatMap(l => [new Fr(l.getEmittedLength()), ...l.getEmittedFields()]));
+      flattened.push(this.toPrefix(PRIVATE_LOGS_PREFIX, this.privateLogs.length));
+      flattened.push(...this.privateLogs.flatMap(l => l.toBlobFields()));
     }
     if (this.publicLogs.length) {
-      const totalLogLen = this.publicLogs.reduce(
-        // +1 for length prefix
-        (total, log) => total + (log.getEmittedLength() == 0 ? 0 : log.getEmittedLength() + 1),
-        0,
-      );
-      flattened.push(this.toPrefix(PUBLIC_LOGS_PREFIX, totalLogLen));
-      flattened.push(...this.publicLogs.flatMap(l => [new Fr(l.getEmittedLength()), ...l.getEmittedFields()]));
+      flattened.push(this.toPrefix(PUBLIC_LOGS_PREFIX, this.publicLogs.length));
+      flattened.push(...this.publicLogs.flatMap(l => l.toBlobFields()));
     }
     if (this.contractClassLogs.length) {
-      const totalLogLen = this.contractClassLogs.reduce(
-        // +2 for length prefix and contract address
-        (total, log) => total + (log.getEmittedLength() == 0 ? 0 : log.getEmittedLength() + 2),
-        0,
-      );
-      flattened.push(this.toPrefix(CONTRACT_CLASS_LOGS_PREFIX, totalLogLen));
-      flattened.push(
-        ...this.contractClassLogs.flatMap(l => [
-          new Fr(l.getEmittedLength()),
-          l.contractAddress.toField(),
-          ...l.getEmittedFields(),
-        ]),
-      );
+      flattened.push(this.toPrefix(CONTRACT_CLASS_LOGS_PREFIX, this.contractClassLogs.length));
+      flattened.push(...this.contractClassLogs.flatMap(l => l.toBlobFields()));
     }
 
     // The first value appended to each list of fields representing a tx effect is:
@@ -404,16 +404,20 @@ export class TxEffect {
         throw new Error('Invalid fields given to TxEffect.fromBlobFields(): Attempted to assign property twice.');
       }
     };
+
     const effect = this.empty();
-    if (!(fields instanceof FieldReader) && !fields.length) {
+    const reader = FieldReader.asReader(fields);
+    const totalFields = reader.remainingFields();
+    if (!totalFields) {
       return effect;
     }
-    const reader = FieldReader.asReader(fields);
+
     const firstField = reader.readField();
     if (!this.isFirstField(firstField)) {
       throw new Error('Invalid fields given to TxEffect.fromBlobFields(): First field invalid.');
     }
-    const { length: _, revertCode } = this.decodeFirstField(firstField);
+
+    const { length: fieldsToProcess, revertCode } = this.decodeFirstField(firstField);
     effect.revertCode = RevertCode.fromField(new Fr(revertCode));
 
     effect.txHash = new TxHash(reader.readField());
@@ -422,7 +426,9 @@ export class TxEffect {
     // NB: Fr.fromBuffer hangs here if you provide a buffer less than 32 in len
     // todo: try new Fr(prefixedFee.toBuffer().subarray(3))
     effect.transactionFee = Fr.fromBuffer(Buffer.concat([Buffer.alloc(3), prefixedFee.toBuffer().subarray(3)]));
-    while (!reader.isFinished()) {
+
+    let fieldsProcessed = totalFields - reader.remainingFields();
+    while (fieldsProcessed < fieldsToProcess) {
       const { type, length } = this.fromPrefix(reader.readField());
       switch (type) {
         case NOTES_PREFIX:
@@ -439,58 +445,29 @@ export class TxEffect {
           break;
         case PUBLIC_DATA_UPDATE_REQUESTS_PREFIX: {
           ensureEmpty(effect.publicDataWrites);
-          const publicDataPairs = reader.readFieldArray(length);
-          for (let i = 0; i < length; i += 2) {
-            effect.publicDataWrites.push(new PublicDataWrite(publicDataPairs[i], publicDataPairs[i + 1]));
-          }
+          effect.publicDataWrites = Array.from({ length }, () => PublicDataWrite.fromBlobFields(reader));
           break;
         }
         case PRIVATE_LOGS_PREFIX: {
           ensureEmpty(effect.privateLogs);
-          const flatPrivateLogs = reader.readFieldArray(length);
-          let i = 0;
-          while (i < length) {
-            const logLen = flatPrivateLogs[i++].toNumber();
-            const logFields = flatPrivateLogs.slice(i, (i += logLen));
-            effect.privateLogs.push(
-              PrivateLog.fromFields(logFields.concat(new Array(PRIVATE_LOG_SIZE_IN_FIELDS - logLen).fill(Fr.ZERO))),
-            );
-          }
+          effect.privateLogs = Array.from({ length }, () => PrivateLog.fromBlobFields(reader));
           break;
         }
         case PUBLIC_LOGS_PREFIX: {
           ensureEmpty(effect.publicLogs);
-          const flatPublicLogs = reader.readFieldArray(length);
-          let i = 0;
-          while (i < length) {
-            const logLen = flatPublicLogs[i++].toNumber();
-            const logFields = flatPublicLogs.slice(i, (i += logLen));
-            effect.publicLogs.push(
-              PublicLog.fromFields(logFields.concat(new Array(PUBLIC_LOG_SIZE_IN_FIELDS - logLen).fill(Fr.ZERO))),
-            );
-          }
+          effect.publicLogs = Array.from({ length }, () => PublicLog.fromBlobFields(reader));
           break;
         }
         case CONTRACT_CLASS_LOGS_PREFIX: {
           ensureEmpty(effect.contractClassLogs);
-          const flatContractClassLogs = reader.readFieldArray(length);
-          let i = 0;
-          while (i < length) {
-            const logLen = flatContractClassLogs[i++].toNumber();
-            // +1 for address
-            const logFields = flatContractClassLogs.slice(i, (i += logLen + 1));
-            effect.contractClassLogs.push(
-              ContractClassLog.fromFields(
-                logFields.concat(new Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - logLen).fill(Fr.ZERO)),
-              ),
-            );
-          }
+          effect.contractClassLogs = Array.from({ length }, () => ContractClassLog.fromBlobFields(reader));
           break;
         }
         case REVERT_CODE_PREFIX:
         default:
           throw new Error(`Too many fields to decode given to TxEffect.fromBlobFields()`);
       }
+      fieldsProcessed = totalFields - reader.remainingFields();
     }
     return effect;
   }
@@ -529,16 +506,23 @@ export class TxEffect {
 
   [inspect.custom]() {
     return `TxEffect {
-      revertCode: ${this.revertCode},
+      revertCode: ${this.revertCode.getCode()},
       txHash: ${this.txHash},
       transactionFee: ${this.transactionFee},
       note hashes: [${this.noteHashes.map(h => h.toString()).join(', ')}],
       nullifiers: [${this.nullifiers.map(h => h.toString()).join(', ')}],
       l2ToL1Msgs: [${this.l2ToL1Msgs.map(h => h.toString()).join(', ')}],
       publicDataWrites: [${this.publicDataWrites.map(h => h.toString()).join(', ')}],
-      privateLogs: [${this.privateLogs.map(l => l.toString()).join(', ')}],
-      publicLogs: [${this.publicLogs.map(l => l.toString()).join(', ')}],
-      contractClassLogs: [${this.contractClassLogs.map(l => l.toString()).join(', ')}],
+      privateLogs: [${this.privateLogs.map(l => l.fields.map(f => f.toString()).join(',')).join(', ')}],
+      publicLogs: [${this.publicLogs.map(l => l.fields.map(f => f.toString()).join(',')).join(', ')}],
+      contractClassLogs: [${this.contractClassLogs
+        .map(l =>
+          l
+            .toFields()
+            .map(f => f.toString())
+            .join(','),
+        )
+        .join(', ')}],
      }`;
   }
 

package/src/tx/tx_execution_request.ts

@@ -54,6 +54,11 @@ export class TxExecutionRequest {
      * Read-only data passed through the oracle calls during this tx execution.
      */
     public capsules: Capsule[],
+    /**
+     * A salt to make the tx request hash difficult to predict.
+     * The hash is used as the first nullifier if there is no nullifier emitted throughout the tx.
+     */
+    public salt = Fr.random(),
   ) {}
 
   static get schema(): ZodFor<TxExecutionRequest> {
@@ -66,6 +71,7 @@ export class TxExecutionRequest {
         argsOfCalls: z.array(HashedValues.schema),
         authWitnesses: z.array(AuthWitness.schema),
         capsules: z.array(Capsule.schema),
+        salt: schemas.Fr,
       })
       .transform(TxExecutionRequest.from);
   }
@@ -73,10 +79,11 @@ export class TxExecutionRequest {
   toTxRequest(): TxRequest {
     return new TxRequest(
       this.origin,
-      // Entrypoints must be private as as defined by the protocol.
-      new FunctionData(this.functionSelector, true /* isPrivate */),
       this.firstCallArgsHash,
       this.txContext,
+      // Entrypoints must be private as defined by the protocol.
+      new FunctionData(this.functionSelector, true /* isPrivate */),
+      this.salt,
     );
   }
 
@@ -89,6 +96,7 @@ export class TxExecutionRequest {
       fields.argsOfCalls,
       fields.authWitnesses,
       fields.capsules,
+      fields.salt,
     ] as const;
   }
 
@@ -109,6 +117,7 @@ export class TxExecutionRequest {
       new Vector(this.argsOfCalls),
       new Vector(this.authWitnesses),
       new Vector(this.capsules),
+      this.salt,
     );
   }
 
@@ -135,6 +144,7 @@ export class TxExecutionRequest {
       reader.readVector(HashedValues),
       reader.readVector(AuthWitness),
       reader.readVector(Capsule),
+      Fr.fromBuffer(reader),
     );
   }
 
@@ -153,12 +163,13 @@ export class TxExecutionRequest {
       FunctionSelector.random(),
       Fr.random(),
       TxContext.empty(),
-      [await HashedValues.random()],
+      [HashedValues.random()],
       [AuthWitness.random()],
       [
         new Capsule(await AztecAddress.random(), Fr.random(), [Fr.random(), Fr.random()]),
         new Capsule(await AztecAddress.random(), Fr.random(), [Fr.random()]),
       ],
+      Fr.random(),
     );
   }
 

package/src/tx/tx_hash.ts

@@ -1,10 +1,11 @@
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader } from '@aztec/foundation/serialize';
+import { BufferReader, serializeArrayOfBufferableToVector } from '@aztec/foundation/serialize';
 
 import { schemas } from '../schemas/index.js';
 
 /**
  * A class representing hash of Aztec transaction.
+ * @dev Computed by hashing the public inputs of the private kernel tail circuit (see Tx::getTxHash function).
  */
 export class TxHash {
   constructor(
@@ -12,10 +13,6 @@ export class TxHash {
     public readonly hash: Fr,
   ) {}
 
-  /*
-   * TxHashes are generated from the first nullifier of a transaction, which is a Fr.
-   * @returns A random TxHash.
-   */
   static random() {
     return new TxHash(Fr.random());
   }
@@ -33,6 +30,10 @@ export class TxHash {
     return new TxHash(new Fr(value));
   }
 
+  static fromField(value: Fr) {
+    return new TxHash(value);
+  }
+
   public toBuffer() {
     return this.hash.toBuffer();
   }
@@ -65,3 +66,23 @@ export class TxHash {
     return Fr.SIZE_IN_BYTES;
   }
 }
+
+/**
+ * Helper class to handle Serialization and Deserialization of TxHashes array.
+ **/
+export class TxHashArray extends Array<TxHash> {
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    try {
+      const reader = BufferReader.asReader(buffer);
+      const hashes = reader.readVector(TxHash);
+
+      return new TxHashArray(...hashes);
+    } catch {
+      return new TxHashArray();
+    }
+  }
+
+  public toBuffer(): Buffer {
+    return serializeArrayOfBufferableToVector([...this]);
+  }
+}

package/src/tx/tx_receipt.ts

@@ -1,9 +1,7 @@
-import type { Fr } from '@aztec/foundation/fields';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
 import { L2BlockHash } from '../block/block_hash.js';
 import { type ZodFor, schemas } from '../schemas/schemas.js';
@@ -41,8 +39,6 @@ export class TxReceipt {
     public blockHash?: L2BlockHash,
     /** The block number in which the transaction was included. */
     public blockNumber?: number,
-    /** Information useful for testing/debugging, set when test flag is set to true in `waitOpts`. */
-    public debugInfo?: DebugInfo,
   ) {}
 
   static empty() {
@@ -58,7 +54,6 @@ export class TxReceipt {
         blockHash: L2BlockHash.schema.optional(),
         blockNumber: z.number().int().nonnegative().optional(),
         transactionFee: schemas.BigInt.optional(),
-        debugInfo: DebugInfoSchema.optional(),
       })
       .transform(TxReceipt.from);
   }
@@ -71,7 +66,6 @@ export class TxReceipt {
       fields.transactionFee,
       fields.blockHash,
       fields.blockNumber,
-      fields.debugInfo,
     );
   }
 
@@ -85,37 +79,7 @@ export class TxReceipt {
     } else if (revertCode.equals(RevertCode.BOTH_REVERTED)) {
       return TxStatus.BOTH_REVERTED;
     } else {
-      throw new Error(`Unknown revert code: ${revertCode}`);
+      throw new Error(`Unknown revert code: ${revertCode.getCode()}`);
     }
   }
 }
-
-/**
- * Information useful for debugging/testing purposes included in the receipt when the debug flag is set to true
- * in `WaitOpts`.
- */
-interface DebugInfo {
-  /**
-   * New note hashes created by the transaction.
-   */
-  noteHashes: Fr[];
-  /**
-   * New nullifiers created by the transaction.
-   */
-  nullifiers: Fr[];
-  /**
-   * New public data writes created by the transaction.
-   */
-  publicDataWrites: PublicDataWrite[];
-  /**
-   * New L2 to L1 messages created by the transaction.
-   */
-  l2ToL1Msgs: Fr[];
-}
-
-const DebugInfoSchema = z.object({
-  noteHashes: z.array(schemas.Fr),
-  nullifiers: z.array(schemas.Fr),
-  publicDataWrites: z.array(PublicDataWrite.schema),
-  l2ToL1Msgs: z.array(schemas.Fr),
-});

package/src/tx/tx_request.ts

@@ -16,16 +16,19 @@ export class TxRequest {
   constructor(
     /** Sender. */
     public origin: AztecAddress,
-    /** Function data representing the function to call. */
-    public functionData: FunctionData,
     /** Pedersen hash of function arguments. */
     public argsHash: Fr,
     /** Transaction context. */
     public txContext: TxContext,
+    /** Function data representing the function to call. */
+    public functionData: FunctionData,
+    /** A salt to make the hash difficult to predict. The hash is used as the first nullifier if there is no nullifier emitted throughout the tx. */
+    public salt: Fr,
   ) {}
   // docs:end:constructor
+
   static getFields(fields: FieldsOf<TxRequest>) {
-    return [fields.origin, fields.functionData, fields.argsHash, fields.txContext] as const;
+    return [fields.origin, fields.argsHash, fields.txContext, fields.functionData, fields.salt] as const;
   }
 
   static from(fields: FieldsOf<TxRequest>): TxRequest {
@@ -57,9 +60,10 @@ export class TxRequest {
     const reader = BufferReader.asReader(buffer);
     return new TxRequest(
       reader.readObject(AztecAddress),
-      reader.readObject(FunctionData),
       Fr.fromBuffer(reader),
       reader.readObject(TxContext),
+      reader.readObject(FunctionData),
+      Fr.fromBuffer(reader),
     );
   }
 
@@ -68,10 +72,16 @@ export class TxRequest {
   }
 
   static empty() {
-    return new TxRequest(AztecAddress.ZERO, FunctionData.empty(), Fr.zero(), TxContext.empty());
+    return new TxRequest(AztecAddress.ZERO, Fr.zero(), TxContext.empty(), FunctionData.empty(), Fr.zero());
   }
 
   isEmpty() {
-    return this.origin.isZero() && this.functionData.isEmpty() && this.argsHash.isZero() && this.txContext.isEmpty();
+    return (
+      this.origin.isZero() &&
+      this.argsHash.isZero() &&
+      this.txContext.isEmpty() &&
+      this.functionData.isEmpty() &&
+      this.salt.isZero()
+    );
   }
 }

package/src/tx/validator/error_texts.ts

@@ -0,0 +1,38 @@
+// Gas and fees
+export const TX_ERROR_INSUFFICIENT_FEE_PER_GAS = 'Insufficient fee per gas';
+export const TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE = 'Insufficient fee payer balance';
+export const TX_ERROR_INSUFFICIENT_GAS_LIMIT = 'Gas limit is below the minimum fixed cost';
+export const TX_ERROR_GAS_LIMIT_TOO_HIGH = 'Gas limit is higher than the amount of gas that the AVM can process';
+
+// Phases
+export const TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED = 'Setup function not on allow list';
+
+// Nullifiers
+export const TX_ERROR_DUPLICATE_NULLIFIER_IN_TX = 'Duplicate nullifier in tx';
+export const TX_ERROR_EXISTING_NULLIFIER = 'Existing nullifier';
+
+// Metadata
+export const TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP = 'Invalid expiration timestamp';
+export const TX_ERROR_INCORRECT_L1_CHAIN_ID = 'Incorrect L1 chain id';
+export const TX_ERROR_INCORRECT_ROLLUP_VERSION = 'Incorrect rollup version';
+export const TX_ERROR_INCORRECT_VK_TREE_ROOT = 'Incorrect verification keys tree root';
+export const TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT = 'Incorrect protocol contracts tree root';
+
+// Proof
+export const TX_ERROR_INVALID_PROOF = 'Invalid proof';
+
+//Data
+export const TX_ERROR_INCORRECT_CALLDATA = 'Incorrect calldata for public call';
+export const TX_ERROR_CALLDATA_COUNT_MISMATCH = 'Wrong number of calldata for public calls';
+export const TX_ERROR_CALLDATA_COUNT_TOO_LARGE = 'Total calldata too large for enqueued public calls';
+export const TX_ERROR_CONTRACT_CLASS_LOG_COUNT = 'Mismatched number of contract class logs';
+export const TX_ERROR_CONTRACT_CLASS_LOG_LENGTH = 'Incorrect contract class logs length';
+export const TX_ERROR_CONTRACT_CLASS_LOGS = 'Mismatched contract class logs';
+export const TX_ERROR_CONTRACT_CLASS_LOG_SORTING = 'Incorrectly sorted contract class logs';
+export const TX_ERROR_INCORRECT_HASH = 'Incorrect tx hash';
+
+// Block header
+export const TX_ERROR_BLOCK_HEADER = 'Block header not found';
+
+// General
+export const TX_ERROR_DURING_VALIDATION = 'Unexpected error during validation';

package/src/tx/validator/tx_validator.ts

@@ -3,9 +3,14 @@ import { z } from 'zod';
 import type { ZodFor } from '../../schemas/schemas.js';
 import type { ProcessedTx } from '../processed_tx.js';
 import type { Tx } from '../tx.js';
+import type { TxHash } from '../tx_hash.js';
 
 export type AnyTx = Tx | ProcessedTx;
 
+export function getTxHash(tx: AnyTx): TxHash {
+  return 'txHash' in tx ? tx.txHash : tx.hash;
+}
+
 export function hasPublicCalls(tx: AnyTx): boolean {
   return tx.data.numberOfPublicCallRequests() > 0;
 }

package/src/types/shared.ts

@@ -25,6 +25,16 @@ export class Vector<T extends Bufferable> {
  */
 export type UInt32 = number;
 
+/**
+ * A type alias for a 64-bit unsigned integer.
+ */
+export type UInt64 = bigint;
+
+/**
+ * A type alias for a 128-bit unsigned integer.
+ */
+export type UInt128 = bigint;
+
 /**
  * CircuitType replaces ComposerType for now. When using Plonk, CircuitType is equivalent to the information of the proving system that will be used
  * to construct a proof. In the future Aztec zk stack, more information must be specified (e.g., the curve over which circuits are  constructed;
@@ -34,12 +44,3 @@ export enum CircuitType {
   STANDARD = 0,
   ULTRA = 1,
 }
-
-/**
- * Rollup types.
- */
-export enum RollupTypes {
-  Base = 0,
-  Merge = 1,
-  Root = 2,
-}

package/src/update-checker/index.ts

@@ -0,0 +1 @@
+export { UpdateChecker, getPackageVersion } from './update-checker.js';