@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/logs/log_with_tx_data.ts

@@ -0,0 +1,36 @@
+import { MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+
+// TypeScript representation of the Noir aztec::oracle::note_discovery::LogWithTxData struct. This is used as a response
+// for PXE's custom getLogByTag oracle.
+export class LogWithTxData {
+  constructor(
+    public logContent: Fr[],
+    public txHash: Fr,
+    public uniqueNoteHashesInTx: Fr[],
+    public firstNullifierInTx: Fr,
+  ) {}
+
+  toNoirSerialization(): (Fr | Fr[])[] {
+    return [
+      ...toBoundedVecSerialization(this.logContent, PUBLIC_LOG_DATA_SIZE_IN_FIELDS),
+      this.txHash,
+      ...toBoundedVecSerialization(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
+      this.firstNullifierInTx,
+    ];
+  }
+
+  static noirSerializationOfEmpty(): (Fr | Fr[])[] {
+    return new LogWithTxData([], new Fr(0), [], new Fr(0)).toNoirSerialization();
+  }
+}
+
+function toBoundedVecSerialization(array: Fr[], maxLength: number) {
+  if (array.length > maxLength) {
+    throw new Error(
+      `An array of length ${array.length} cannot be converted to a BoundedVec of max length ${maxLength}`,
+    );
+  }
+
+  return [array.concat(Array(maxLength - array.length).fill(new Fr(0))), new Fr(array.length)];
+}

package/src/logs/private_log.ts

@@ -0,0 +1,58 @@
+import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { inspect } from 'util';
+import { z } from 'zod';
+
+export class PrivateLog {
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PRIVATE_LOG_SIZE_IN_FIELDS;
+
+  constructor(public fields: Tuple<Fr, typeof PRIVATE_LOG_SIZE_IN_FIELDS>) {}
+
+  toFields(): Fr[] {
+    return this.fields;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new PrivateLog(reader.readFieldArray(PRIVATE_LOG_SIZE_IN_FIELDS));
+  }
+
+  isEmpty() {
+    return this.fields.every(f => f.isZero());
+  }
+
+  static empty() {
+    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.zero));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.fields);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr));
+  }
+
+  static random() {
+    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random));
+  }
+
+  static get schema() {
+    return z
+      .object({
+        fields: z.array(schemas.Fr),
+      })
+      .transform(({ fields }) => PrivateLog.fromFields(fields));
+  }
+
+  [inspect.custom](): string {
+    return `PrivateLog {
+      fields: [${this.fields.map(x => inspect(x)).join(', ')}],
+    }`;
+  }
+}

package/src/logs/public_log.ts

@@ -0,0 +1,83 @@
+import { PUBLIC_LOG_DATA_SIZE_IN_FIELDS, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
+
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+export class PublicLog {
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_SIZE_IN_FIELDS;
+
+  constructor(public contractAddress: AztecAddress, public log: Tuple<Fr, typeof PUBLIC_LOG_DATA_SIZE_IN_FIELDS>) {}
+
+  toFields(): Fr[] {
+    return serializeToFields(...PublicLog.getFields(this));
+  }
+
+  static getFields(fields: FieldsOf<PublicLog>) {
+    return [fields.contractAddress, fields.log] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new PublicLog(reader.readObject(AztecAddress), reader.readFieldArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS));
+  }
+
+  isEmpty() {
+    return this.contractAddress.isZero() && this.log.every(f => f.isZero());
+  }
+
+  static empty() {
+    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr.zero));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(...PublicLog.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicLog(reader.readObject(AztecAddress), reader.readArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr));
+  }
+
+  static async random() {
+    return new PublicLog(await AztecAddress.random(), makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr.random));
+  }
+
+  equals(other: this) {
+    return (
+      this.contractAddress.equals(other.contractAddress) &&
+      this.log.reduce((acc, field, i) => acc && field.equals(other.log[i]), true)
+    );
+  }
+
+  toHumanReadable(): string {
+    return `PublicLog: (contractAddress: ${this.contractAddress} log: ${this.log})`;
+  }
+
+  static get schema(): ZodFor<PublicLog> {
+    return z
+      .object({
+        contractAddress: AztecAddress.schema,
+        log: z.array(schemas.Fr),
+      })
+      .transform(({ contractAddress, log }) => PublicLog.fromFields([contractAddress.toField(), ...log]));
+  }
+
+  [inspect.custom](): string {
+    return `PublicLog {
+      contractAddress: ${inspect(this.contractAddress)},
+      log: [${this.log.map(x => inspect(x)).join(', ')}],
+    }`;
+  }
+}

package/src/logs/tx_scoped_l2_log.ts

@@ -0,0 +1,83 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { schemas } from '../schemas/schemas.js';
+import { TxHash } from '../tx/tx_hash.js';
+
+export class TxScopedL2Log {
+  constructor(
+    /*
+     * Hash of the tx where the log is included
+     */
+    public txHash: TxHash,
+    /*
+     * The next available leaf index for the note hash tree for this transaction. It is stored
+     * with the log so the noteHashIndex can be reconstructed after decryption.
+     */
+    public dataStartIndexForTx: number,
+    /*
+     * The block this log is included in
+     */
+    public blockNumber: number,
+    /*
+     * Indicates if the log comes from the public logs stream (partial note)
+     */
+    public isFromPublic: boolean,
+    /*
+     * The log data
+     */
+    public logData: Buffer,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        txHash: TxHash.schema,
+        dataStartIndexForTx: z.number(),
+        blockNumber: z.number(),
+        isFromPublic: z.boolean(),
+        logData: schemas.Buffer,
+      })
+      .transform(
+        ({ txHash, dataStartIndexForTx, blockNumber, isFromPublic, logData }) =>
+          new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, isFromPublic, logData),
+      );
+  }
+
+  toBuffer() {
+    return Buffer.concat([
+      this.txHash.toBuffer(),
+      numToUInt32BE(this.dataStartIndexForTx),
+      numToUInt32BE(this.blockNumber),
+      boolToBuffer(this.isFromPublic),
+      this.logData,
+    ]);
+  }
+
+  static fromBuffer(buffer: Buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new TxScopedL2Log(
+      reader.readObject(TxHash),
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readBoolean(),
+      reader.readToEnd(),
+    );
+  }
+
+  static random() {
+    return new TxScopedL2Log(TxHash.random(), 1, 1, false, Fr.random().toBuffer());
+  }
+
+  equals(other: TxScopedL2Log) {
+    return (
+      this.txHash.equals(other.txHash) &&
+      this.dataStartIndexForTx === other.dataStartIndexForTx &&
+      this.blockNumber === other.blockNumber &&
+      this.isFromPublic === other.isFromPublic &&
+      this.logData.equals(other.logData)
+    );
+  }
+}

package/src/messaging/inbox_leaf.ts

@@ -0,0 +1,28 @@
+import { INITIAL_L2_BLOCK_NUM, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+export class InboxLeaf {
+  constructor(
+    /** Index of the leaf in the whole tree. */
+    public readonly index: bigint,
+    /** Leaf in the subtree/message hash. */
+    public readonly leaf: Fr,
+  ) {}
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.index, this.leaf]);
+  }
+
+  fromBuffer(buffer: Buffer | BufferReader): InboxLeaf {
+    const reader = BufferReader.asReader(buffer);
+    const index = toBigIntBE(reader.readBytes(32));
+    const leaf = reader.readObject(Fr);
+    return new InboxLeaf(index, leaf);
+  }
+
+  static smallestIndexFromL2Block(l2block: bigint): bigint {
+    return (l2block - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  }
+}

package/src/messaging/index.ts

@@ -0,0 +1,6 @@
+export * from './inbox_leaf.js';
+export * from './l1_to_l2_message.js';
+export * from './l1_to_l2_message_source.js';
+export * from './l1_actor.js';
+export * from './l2_actor.js';
+export * from './l2_to_l1_message.js';

package/src/messaging/l1_actor.ts

@@ -0,0 +1,43 @@
+import { randomInt } from '@aztec/foundation/crypto';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+/**
+ * The sender of an L1 to L2 message or recipient of an L2 to L1 message.
+ */
+export class L1Actor {
+  constructor(
+    /**
+     * The sender of the message.
+     */
+    public readonly sender: EthAddress,
+    /**
+     * The chain id on which the message was sent (L1 -> L2) or on which the message will be received (L2 -> L1).
+     */
+    public readonly chainId: number,
+  ) {}
+
+  static empty() {
+    return new L1Actor(EthAddress.ZERO, 0);
+  }
+
+  toFields(): Fr[] {
+    return [this.sender.toField(), new Fr(BigInt(this.chainId))];
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.sender, this.chainId);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): L1Actor {
+    const reader = BufferReader.asReader(buffer);
+    const ethAddr = reader.readObject(EthAddress);
+    const chainId = reader.readNumber();
+    return new L1Actor(ethAddr, chainId);
+  }
+
+  static random(): L1Actor {
+    return new L1Actor(EthAddress.random(), randomInt(1000));
+  }
+}

package/src/messaging/l1_to_l2_message.ts

@@ -0,0 +1,97 @@
+import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import { sha256ToField } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex } from '@aztec/foundation/string';
+import { SiblingPath } from '@aztec/foundation/trees';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { computeL1ToL2MessageNullifier } from '../hash/hash.js';
+import type { AztecNode } from '../interfaces/aztec-node.js';
+import { MerkleTreeId } from '../trees/merkle_tree_id.js';
+import { L1Actor } from './l1_actor.js';
+import { L2Actor } from './l2_actor.js';
+
+/**
+ * The format of an L1 to L2 Message.
+ */
+export class L1ToL2Message {
+  constructor(
+    /** The sender of the message on L1. */
+    public readonly sender: L1Actor,
+    /** The recipient of the message on L2. */
+    public readonly recipient: L2Actor,
+    /** The message content. */
+    public readonly content: Fr,
+    /** The hash of the spending secret. */
+    public readonly secretHash: Fr,
+    /** Global index of this message on the tree. */
+    public readonly index: Fr,
+  ) {}
+
+  /**
+   * Returns each element within its own field so that it can be consumed by an acvm oracle call.
+   * @returns The message as an array of fields (in order).
+   */
+  toFields(): Fr[] {
+    return [...this.sender.toFields(), ...this.recipient.toFields(), this.content, this.secretHash, this.index];
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.sender, this.recipient, this.content, this.secretHash, this.index);
+  }
+
+  hash(): Fr {
+    return sha256ToField(this.toFields());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): L1ToL2Message {
+    const reader = BufferReader.asReader(buffer);
+    const sender = reader.readObject(L1Actor);
+    const recipient = reader.readObject(L2Actor);
+    const content = Fr.fromBuffer(reader);
+    const secretHash = Fr.fromBuffer(reader);
+    const index = Fr.fromBuffer(reader);
+    return new L1ToL2Message(sender, recipient, content, secretHash, index);
+  }
+
+  toString(): string {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(data: string): L1ToL2Message {
+    const buffer = Buffer.from(data, 'hex');
+    return L1ToL2Message.fromBuffer(buffer);
+  }
+
+  static empty(): L1ToL2Message {
+    return new L1ToL2Message(L1Actor.empty(), L2Actor.empty(), Fr.ZERO, Fr.ZERO, Fr.ZERO);
+  }
+
+  static async random(): Promise<L1ToL2Message> {
+    return new L1ToL2Message(L1Actor.random(), await L2Actor.random(), Fr.random(), Fr.random(), Fr.random());
+  }
+}
+
+// This functionality is not on the node because we do not want to pass the node the secret, and give the node the ability to derive a valid nullifer for an L1 to L2 message.
+export async function getNonNullifiedL1ToL2MessageWitness(
+  node: AztecNode,
+  contractAddress: AztecAddress,
+  messageHash: Fr,
+  secret: Fr,
+): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
+  const response = await node.getL1ToL2MessageMembershipWitness('latest', messageHash);
+  if (!response) {
+    throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
+  }
+  const [messageIndex, siblingPath] = response;
+
+  const messageNullifier = await computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);
+
+  const [nullifierIndex] = await node.findLeavesIndexes('latest', MerkleTreeId.NULLIFIER_TREE, [messageNullifier]);
+  if (nullifierIndex !== undefined) {
+    throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
+  }
+
+  return [messageIndex, siblingPath];
+}

package/src/messaging/l1_to_l2_message_source.ts

@@ -0,0 +1,26 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+/**
+ * Interface of classes allowing for the retrieval of L1 to L2 messages.
+ */
+export interface L1ToL2MessageSource {
+  /**
+   * Gets new L1 to L2 message (to be) included in a given block.
+   * @param blockNumber - L2 block number to get messages for.
+   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
+   */
+  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
+
+  /**
+   * Gets the L1 to L2 message index in the L1 to L2 message tree.
+   * @param l1ToL2Message - The L1 to L2 message.
+   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
+   */
+  getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined>;
+
+  /**
+   * Gets the number of the latest L2 block processed by the implementation.
+   * @returns The number of the latest L2 block processed by the implementation.
+   */
+  getBlockNumber(): Promise<number>;
+}

package/src/messaging/l2_actor.ts

@@ -0,0 +1,44 @@
+import { randomInt } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+/**
+ * The recipient of an L2 message.
+ */
+export class L2Actor {
+  constructor(
+    /**
+     * The recipient of the message.
+     */
+    public readonly recipient: AztecAddress,
+    /**
+     * The version of the protocol.
+     */
+    public readonly version: number,
+  ) {}
+
+  static empty() {
+    return new L2Actor(AztecAddress.ZERO, 0);
+  }
+
+  toFields(): Fr[] {
+    return [this.recipient.toField(), new Fr(BigInt(this.version))];
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.recipient, this.version);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): L2Actor {
+    const reader = BufferReader.asReader(buffer);
+    const aztecAddr = AztecAddress.fromBuffer(reader);
+    const version = reader.readNumber();
+    return new L2Actor(aztecAddr, version);
+  }
+
+  static async random(): Promise<L2Actor> {
+    return new L2Actor(await AztecAddress.random(), randomInt(1000));
+  }
+}

package/src/messaging/l2_to_l1_message.ts

@@ -0,0 +1,128 @@
+import { L2_TO_L1_MESSAGE_LENGTH, SCOPED_L2_TO_L1_MESSAGE_LENGTH } from '@aztec/constants';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+export class L2ToL1Message {
+  constructor(public recipient: EthAddress, public content: Fr, public counter: number) {}
+
+  /**
+   * Creates an empty L2ToL1Message with default values.
+   * @returns An instance of L2ToL1Message with empty fields.
+   */
+  static empty(): L2ToL1Message {
+    return new L2ToL1Message(EthAddress.ZERO, Fr.zero(), 0);
+  }
+
+  /**
+   * Checks if another L2ToL1Message is equal to this instance.
+   * @param other Another L2ToL1Message instance to compare with.
+   * @returns True if both recipient and content are equal.
+   */
+  equals(other: L2ToL1Message): boolean {
+    return (
+      this.recipient.equals(other.recipient) && this.content.equals(other.content) && this.counter === other.counter
+    );
+  }
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.recipient, this.content, this.counter);
+  }
+
+  /**
+   * Serializes the L2ToL1Message into an array of fields.
+   * @returns An array of fields representing the serialized message.
+   */
+  toFields(): Fr[] {
+    const fields = [this.recipient.toField(), this.content, new Fr(this.counter)];
+    if (fields.length !== L2_TO_L1_MESSAGE_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for L2ToL1Message. Expected ${L2_TO_L1_MESSAGE_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  /**
+   * Deserializes an array of fields into an L2ToL1Message instance.
+   * @param fields An array of fields to deserialize from.
+   * @returns An instance of L2ToL1Message.
+   */
+  static fromFields(fields: Fr[] | FieldReader): L2ToL1Message {
+    const reader = FieldReader.asReader(fields);
+    return new L2ToL1Message(reader.readObject(EthAddress), reader.readField(), reader.readU32());
+  }
+
+  /**
+   * Deserializes from a buffer or reader.
+   * @param buffer - Buffer or reader to read from.
+   * @returns A new instance of L2ToL1Message.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): L2ToL1Message {
+    const reader = BufferReader.asReader(buffer);
+    return new L2ToL1Message(reader.readObject(EthAddress), reader.readObject(Fr), reader.readNumber());
+  }
+
+  /**
+   * Convenience method to check if the message is empty.
+   * @returns True if both recipient and content are zero.
+   */
+  isEmpty(): boolean {
+    return this.recipient.isZero() && this.content.isZero() && !this.counter;
+  }
+
+  scope(contractAddress: AztecAddress) {
+    return new ScopedL2ToL1Message(this, contractAddress);
+  }
+}
+
+export class ScopedL2ToL1Message {
+  constructor(public message: L2ToL1Message, public contractAddress: AztecAddress) {}
+
+  static getFields(fields: FieldsOf<ScopedL2ToL1Message>) {
+    return [fields.message, fields.contractAddress] as const;
+  }
+
+  static empty() {
+    return new ScopedL2ToL1Message(L2ToL1Message.empty(), AztecAddress.ZERO);
+  }
+
+  equals(other: ScopedL2ToL1Message): boolean {
+    return this.message.equals(other.message) && this.contractAddress.equals(other.contractAddress);
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.message, this.contractAddress);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new ScopedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readObject(AztecAddress));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new ScopedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readObject(AztecAddress));
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...ScopedL2ToL1Message.getFields(this));
+    if (fields.length !== SCOPED_L2_TO_L1_MESSAGE_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for ScopedL2ToL1Message. Expected ${SCOPED_L2_TO_L1_MESSAGE_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  isEmpty(): boolean {
+    return this.message.isEmpty() && this.contractAddress.isZero();
+  }
+}

package/src/network/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Deployed aztec networks & their names.
+ */
+export enum Network {
+  DEVNET = 'devnet',
+  PROVERNET = 'provernet',
+  ALPHANET = 'alphanet',
+}
+
+/**
+ * Map of basic contracts deployed for each network.
+ */
+export const L2BasicContractsMap = {
+  [Network.DEVNET]: {
+    devCoin: 'TokenContract',
+    devCoinBridge: 'TokenBridgeContract',
+    devCoinFpc: 'FPCContract',
+    counter: 'CounterContract',
+  },
+  [Network.PROVERNET]: {
+    devCoin: 'TokenContract',
+    devCoinBridge: 'TokenBridgeContract',
+    devCoinFpc: 'FPCContract',
+    counter: 'CounterContract',
+  },
+  [Network.ALPHANET]: {
+    devCoin: 'TokenContract',
+    devCoinBridge: 'TokenBridgeContract',
+    devCoinFpc: 'FPCContract',
+    counter: 'CounterContract',
+  },
+};