@aztec/stdlib 0.86.0 → 0.87.0

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,10 +10,8 @@ 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';
@@ -243,8 +240,8 @@ export class TxEffect {
       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))),
+      makeTuple(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),
     );
@@ -372,41 +369,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:
@@ -426,16 +402,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());
@@ -444,7 +424,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:
@@ -461,58 +443,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;
   }
@@ -551,16 +504,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);
   }
@@ -77,6 +83,7 @@ export class TxExecutionRequest {
       new FunctionData(this.functionSelector, true /* isPrivate */),
       this.firstCallArgsHash,
       this.txContext,
+      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),
     );
   }
 
@@ -159,6 +169,7 @@ export class TxExecutionRequest {
         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_receipt.ts

@@ -79,7 +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()}`);
     }
   }
 }

package/src/tx/tx_request.ts

@@ -22,10 +22,12 @@ export class TxRequest {
     public argsHash: Fr,
     /** Transaction context. */
     public txContext: TxContext,
+    /** 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.functionData, fields.argsHash, fields.txContext, fields.salt] as const;
   }
 
   static from(fields: FieldsOf<TxRequest>): TxRequest {
@@ -60,6 +62,7 @@ export class TxRequest {
       reader.readObject(FunctionData),
       Fr.fromBuffer(reader),
       reader.readObject(TxContext),
+      Fr.fromBuffer(reader),
     );
   }
 
@@ -68,10 +71,16 @@ export class TxRequest {
   }
 
   static empty() {
-    return new TxRequest(AztecAddress.ZERO, FunctionData.empty(), Fr.zero(), TxContext.empty());
+    return new TxRequest(AztecAddress.ZERO, FunctionData.empty(), Fr.zero(), TxContext.empty(), Fr.zero());
   }
 
   isEmpty() {
-    return this.origin.isZero() && this.functionData.isEmpty() && this.argsHash.isZero() && this.txContext.isEmpty();
+    return (
+      this.origin.isZero() &&
+      this.functionData.isEmpty() &&
+      this.argsHash.isZero() &&
+      this.txContext.isEmpty() &&
+      this.salt.isZero()
+    );
   }
 }

package/src/tx/validator/error_texts.ts

@@ -12,8 +12,10 @@ export const TX_ERROR_EXISTING_NULLIFIER = 'Existing nullifier';
 
 // Metadata
 export const TX_ERROR_INVALID_BLOCK_NUMBER = 'Invalid block number';
-export const TX_ERROR_INCORRECT_CHAIN_ID = 'Incorrect chain id';
+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 protocol circuits 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';
@@ -23,7 +25,7 @@ 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 = 'Mismatched contract class logs length';
+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';
 

package/src/types/shared.ts

@@ -25,6 +25,11 @@ export class Vector<T extends Bufferable> {
  */
 export type UInt32 = number;
 
+/**
+ * A type alias for a 64-bit unsigned integer.
+ */
+export type UInt64 = 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;

package/src/update-checker/index.ts

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

package/src/update-checker/update-checker.ts

@@ -0,0 +1,152 @@
+import { RegistryContract, type ViemClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { fileURLToPath } from '@aztec/foundation/url';
+
+import { EventEmitter } from 'events';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { isDeepStrictEqual } from 'util';
+import { z } from 'zod';
+
+const updateConfigSchema = z.object({
+  version: z.string().optional(),
+  config: z.any().optional(),
+});
+
+export type EventMap = {
+  newRollupVersion: [{ currentVersion: bigint; latestVersion: bigint }];
+  newNodeVersion: [{ currentVersion: string; latestVersion: string }];
+  updateNodeConfig: [object];
+};
+
+type Config = {
+  baseURL: URL;
+  nodeVersion?: string;
+  checkIntervalMs?: number;
+  registryContractAddress: EthAddress;
+  publicClient: ViemClient;
+  fetch?: typeof fetch;
+};
+
+export class UpdateChecker extends EventEmitter<EventMap> {
+  private runningPromise: RunningPromise;
+  private lastPatchedConfig: object = {};
+
+  constructor(
+    private updatesUrl: URL,
+    private nodeVersion: string | undefined,
+    private rollupVersion: bigint,
+    private fetch: typeof globalThis.fetch,
+    private getLatestRollupVersion: () => Promise<bigint>,
+    private checkIntervalMs = 60_000, // every minute
+    private log = createLogger('foundation:update-check'),
+  ) {
+    super();
+    this.runningPromise = new RunningPromise(this.runChecks, this.log, this.checkIntervalMs);
+  }
+
+  public static async new(config: Config): Promise<UpdateChecker> {
+    const registryContract = new RegistryContract(config.publicClient, config.registryContractAddress);
+    const getLatestRollupVersion = () => registryContract.getRollupVersions().then(versions => versions.at(-1)!);
+
+    return new UpdateChecker(
+      config.baseURL,
+      config.nodeVersion ?? getPackageVersion(),
+      await getLatestRollupVersion(),
+      config.fetch ?? fetch,
+      getLatestRollupVersion,
+      config.checkIntervalMs,
+    );
+  }
+
+  public start(): void {
+    if (this.runningPromise.isRunning()) {
+      this.log.debug(`Can't start update checker again`);
+      return;
+    }
+
+    this.log.info('Starting update checker', {
+      nodeVersion: this.nodeVersion,
+      rollupVersion: this.rollupVersion,
+    });
+    this.runningPromise.start();
+  }
+
+  public stop(): Promise<void> {
+    if (!this.runningPromise.isRunning()) {
+      this.log.debug(`Can't stop update checker because it is not running`);
+      return Promise.resolve();
+    }
+    return this.runningPromise.stop();
+  }
+
+  public trigger(): Promise<void> {
+    return this.runningPromise.trigger();
+  }
+
+  private runChecks = async (): Promise<void> => {
+    await Promise.all([this.checkRollupVersion(), this.checkConfig()]);
+  };
+
+  private async checkRollupVersion(): Promise<void> {
+    try {
+      const canonicalRollupVersion = await this.getLatestRollupVersion();
+      if (canonicalRollupVersion !== this.rollupVersion) {
+        this.log.debug('New canonical rollup version', {
+          currentVersion: this.rollupVersion,
+          latestVersion: canonicalRollupVersion,
+        });
+        this.emit('newRollupVersion', { currentVersion: this.rollupVersion, latestVersion: canonicalRollupVersion });
+      }
+    } catch (err) {
+      this.log.warn(`Failed to check if there is a new rollup`, err);
+    }
+  }
+
+  private async checkConfig(): Promise<void> {
+    try {
+      const response = await this.fetch(this.updatesUrl);
+      const body = await response.json();
+      if (!response.ok) {
+        this.log.warn(`Unexpected HTTP response checking for updates`, {
+          status: response.status,
+          body: await response.text(),
+          url: this.updatesUrl,
+        });
+      }
+
+      const { version, config } = updateConfigSchema.parse(body);
+
+      if (this.nodeVersion && version && version !== this.nodeVersion) {
+        this.log.debug('New node version', { currentVersion: this.nodeVersion, latestVersion: version });
+        this.emit('newNodeVersion', { currentVersion: this.nodeVersion, latestVersion: version });
+      }
+
+      if (config && Object.keys(config).length > 0 && !isDeepStrictEqual(config, this.lastPatchedConfig)) {
+        this.log.debug('New node config', { config });
+        this.lastPatchedConfig = config;
+        this.emit('updateNodeConfig', config);
+      }
+    } catch (err) {
+      this.log.warn(`Failed to check if there is an update`, err);
+    }
+  }
+}
+
+/**
+ * Returns package version.
+ */
+export function getPackageVersion(): string | undefined {
+  try {
+    const releasePleaseManifestPath = resolve(
+      dirname(fileURLToPath(import.meta.url)),
+      '../../../../.release-please-manifest.json',
+    );
+    const version = JSON.parse(readFileSync(releasePleaseManifestPath).toString())['.'];
+    return version;
+  } catch {
+    return undefined;
+  }
+}

package/src/validators/schemas.ts

@@ -31,7 +31,7 @@ const ValidatorTimeStatSchema = z.object({
 
 const ValidatorFilteredHistorySchema = z.object({
   currentStreak: schemas.Integer,
-  rate: z.number(),
+  rate: z.number().optional(),
   count: schemas.Integer,
 });
 

package/src/validators/types.ts

@@ -18,12 +18,12 @@ export type ValidatorStats = {
   totalSlots: number;
   missedProposals: {
     currentStreak: number;
-    rate: number;
+    rate?: number;
     count: number;
   };
   missedAttestations: {
     currentStreak: number;
-    rate: number;
+    rate?: number;
     count: number;
   };
   history: ValidatorStatusHistory;

package/src/versioning/versioning.ts

@@ -4,7 +4,7 @@ import { jsonStringify } from '@aztec/foundation/json-rpc';
 
 import type Koa from 'koa';
 
-import type { ChainConfig } from '../config/config.js';
+import type { ChainConfig } from '../config/chain-config.js';
 
 // REFACTOR: This file is not a circuit-type, but at the moment we don't have any other
 // package common to all components that we can use for this shared code.

package/src/vks/verification_key.ts

@@ -88,7 +88,10 @@ export const CIRCUIT_RECURSIVE_INDEX = 3;
  * Provides a 'fields' representation of a circuit's verification key
  */
 export class VerificationKeyAsFields {
-  constructor(public key: Fr[], public hash: Fr) {}
+  constructor(
+    public key: Fr[],
+    public hash: Fr,
+  ) {}
 
   public get numPublicInputs() {
     return Number(this.key[CIRCUIT_PUBLIC_INPUTS_INDEX]);
@@ -252,7 +255,10 @@ export class VerificationKey {
 }
 
 export class VerificationKeyData {
-  constructor(public readonly keyAsFields: VerificationKeyAsFields, public readonly keyAsBytes: Buffer) {}
+  constructor(
+    public readonly keyAsFields: VerificationKeyAsFields,
+    public readonly keyAsBytes: Buffer,
+  ) {}
 
   public get numPublicInputs() {
     return this.keyAsFields.numPublicInputs;

package/dest/config/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,KAAK,eAAe,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,eAAO,MAAM,gBAAgB,EAAE,WAI9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAAC,WAAW,CAgB/D,CAAC;AAEF,2BAA2B;AAC3B,MAAM,MAAM,WAAW,GAAG;IACxB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,WAAW,EAAE;QACX,4BAA4B;QAC5B,aAAa,EAAE,UAAU,CAAC;KAC3B,CAAC;CACH,CAAC"}

package/dest/tx/profiled_tx.d.ts

@@ -1,9 +0,0 @@
-import type { ZodFor } from '@aztec/foundation/schemas';
-import { type PrivateExecutionStep } from '../kernel/private_kernel_prover_output.js';
-export declare class TxProfileResult {
-    executionSteps: PrivateExecutionStep[];
-    constructor(executionSteps: PrivateExecutionStep[]);
-    static get schema(): ZodFor<TxProfileResult>;
-    static random(): TxProfileResult;
-}
-//# sourceMappingURL=profiled_tx.d.ts.map

package/dest/tx/profiled_tx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"profiled_tx.d.ts","sourceRoot":"","sources":["../../src/tx/profiled_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAIxD,OAAO,EAAE,KAAK,oBAAoB,EAA8B,MAAM,2CAA2C,CAAC;AAElH,qBAAa,eAAe;IACP,cAAc,EAAE,oBAAoB,EAAE;gBAAtC,cAAc,EAAE,oBAAoB,EAAE;IAEzD,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,eAAe,CAAC,CAM3C;IAED,MAAM,CAAC,MAAM,IAAI,eAAe;CAUjC"}

package/dest/tx/profiled_tx.js

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
-export class TxProfileResult {
-    executionSteps;
-    constructor(executionSteps){
-        this.executionSteps = executionSteps;
-    }
-    static get schema() {
-        return z.object({
-            executionSteps: z.array(PrivateExecutionStepSchema)
-        }).transform(({ executionSteps })=>new TxProfileResult(executionSteps));
-    }
-    static random() {
-        return new TxProfileResult([
-            {
-                functionName: 'random',
-                bytecode: Buffer.from('random'),
-                witness: new Map([
-                    [
-                        1,
-                        'random'
-                    ]
-                ]),
-                vk: Buffer.from('random')
-            }
-        ]);
-    }
-}

package/src/tx/profiled_tx.ts

@@ -1,28 +0,0 @@
-import type { ZodFor } from '@aztec/foundation/schemas';
-
-import { z } from 'zod';
-
-import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
-
-export class TxProfileResult {
-  constructor(public executionSteps: PrivateExecutionStep[]) {}
-
-  static get schema(): ZodFor<TxProfileResult> {
-    return z
-      .object({
-        executionSteps: z.array(PrivateExecutionStepSchema),
-      })
-      .transform(({ executionSteps }) => new TxProfileResult(executionSteps));
-  }
-
-  static random(): TxProfileResult {
-    return new TxProfileResult([
-      {
-        functionName: 'random',
-        bytecode: Buffer.from('random'),
-        witness: new Map([[1, 'random']]),
-        vk: Buffer.from('random'),
-      },
-    ]);
-  }
-}