@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/logs/l1_payload/l1_note_payload.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type Fq, Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { NoteSelector } from '../../abi/note_selector.js';
+import { AztecAddress } from '../../aztec-address/index.js';
+import type { PrivateLog } from '../private_log.js';
+import { PublicLog } from '../public_log.js';
+/**
+ * A class which wraps note data which is pushed on L1.
+ * @remarks This data is required to compute a nullifier/to spend a note. Along with that this class contains
+ * the necessary functionality to encrypt and decrypt the data.
+ */
+export declare class L1NotePayload {
+    /**
+     * Address of the contract this tx is interacting with.
+     */
+    contractAddress: AztecAddress;
+    /**
+     * Storage slot of the underlying note.
+     */
+    storageSlot: Fr;
+    /**
+     * Type identifier for the underlying note, required to determine how to compute its hash and nullifier.
+     */
+    noteTypeId: NoteSelector;
+    /**
+     * Note values delivered encrypted.
+     * @dev Note that to recreate the correct note we need to merge privateNoteValues and publicNoteValues. To do that
+     * we need access to the contract ABI (that is done in the NoteProcessor).
+     */
+    privateNoteValues: Fr[];
+    /**
+     * Note values delivered in plaintext.
+     * @dev Note that to recreate the correct note we need to merge privateNoteValues and publicNoteValues. To do that
+     * we need access to the contract ABI (that is done in the NoteProcessor).
+     */
+    publicNoteValues: Fr[];
+    constructor(
+    /**
+     * Address of the contract this tx is interacting with.
+     */
+    contractAddress: AztecAddress, 
+    /**
+     * Storage slot of the underlying note.
+     */
+    storageSlot: Fr, 
+    /**
+     * Type identifier for the underlying note, required to determine how to compute its hash and nullifier.
+     */
+    noteTypeId: NoteSelector, 
+    /**
+     * Note values delivered encrypted.
+     * @dev Note that to recreate the correct note we need to merge privateNoteValues and publicNoteValues. To do that
+     * we need access to the contract ABI (that is done in the NoteProcessor).
+     */
+    privateNoteValues: Fr[], 
+    /**
+     * Note values delivered in plaintext.
+     * @dev Note that to recreate the correct note we need to merge privateNoteValues and publicNoteValues. To do that
+     * we need access to the contract ABI (that is done in the NoteProcessor).
+     */
+    publicNoteValues: Fr[]);
+    static fromIncomingBodyPlaintextContractAndPublicValues(plaintext: Buffer, contractAddress: AztecAddress, publicNoteValues: Fr[]): L1NotePayload | undefined;
+    static decryptAsIncoming(log: PrivateLog, sk: Fq): Promise<L1NotePayload | undefined>;
+    static decryptAsIncomingFromPublic(log: PublicLog, sk: Fq): Promise<L1NotePayload | undefined>;
+    /**
+     * Serializes the L1NotePayload object into a Buffer.
+     * @returns Buffer representation of the L1NotePayload object.
+     */
+    toIncomingBodyPlaintext(): Buffer;
+    /**
+     * Create a random L1NotePayload object (useful for testing purposes).
+     * @param contract - The address of a contract the note was emitted from.
+     * @returns A random L1NotePayload object.
+     */
+    static random(contract?: AztecAddress): Promise<L1NotePayload>;
+    equals(other: L1NotePayload): boolean;
+    toBuffer(): Buffer;
+    static fromBuffer(buffer: Buffer | BufferReader): L1NotePayload;
+}
+//# sourceMappingURL=l1_note_payload.d.ts.map

package/dest/logs/l1_payload/l1_note_payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_note_payload.d.ts","sourceRoot":"","sources":["../../../src/logs/l1_payload/l1_note_payload.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG7C;;;;GAIG;AACH,qBAAa,aAAa;IAEtB;;OAEG;IACI,eAAe,EAAE,YAAY;IACpC;;OAEG;IACI,WAAW,EAAE,EAAE;IACtB;;OAEG;IACI,UAAU,EAAE,YAAY;IAC/B;;;;OAIG;IACI,iBAAiB,EAAE,EAAE,EAAE;IAC9B;;;;OAIG;IACI,gBAAgB,EAAE,EAAE,EAAE;;IAvB7B;;OAEG;IACI,eAAe,EAAE,YAAY;IACpC;;OAEG;IACI,WAAW,EAAE,EAAE;IACtB;;OAEG;IACI,UAAU,EAAE,YAAY;IAC/B;;;;OAIG;IACI,iBAAiB,EAAE,EAAE,EAAE;IAC9B;;;;OAIG;IACI,gBAAgB,EAAE,EAAE,EAAE;IAG/B,MAAM,CAAC,gDAAgD,CACrD,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,YAAY,EAC7B,gBAAgB,EAAE,EAAE,EAAE,GACrB,aAAa,GAAG,SAAS;WAgBf,iBAAiB,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;WAa9E,2BAA2B,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;IAkBpG;;;OAGG;IACH,uBAAuB;IAKvB;;;;OAIG;WACU,MAAM,CAAC,QAAQ,CAAC,EAAE,YAAY;IAgBpC,MAAM,CAAC,KAAK,EAAE,aAAa;IAUlC,QAAQ;IAUR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;CAUhD"}

package/dest/logs/l1_payload/l1_note_payload.js

@@ -0,0 +1,129 @@
+import { randomInt } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { NoteSelector } from '../../abi/note_selector.js';
+import { AztecAddress } from '../../aztec-address/index.js';
+import { Vector } from '../../types/index.js';
+import { EncryptedLogPayload } from './encrypted_log_payload.js';
+/**
+ * A class which wraps note data which is pushed on L1.
+ * @remarks This data is required to compute a nullifier/to spend a note. Along with that this class contains
+ * the necessary functionality to encrypt and decrypt the data.
+ */ export class L1NotePayload {
+    contractAddress;
+    storageSlot;
+    noteTypeId;
+    privateNoteValues;
+    publicNoteValues;
+    constructor(/**
+     * Address of the contract this tx is interacting with.
+     */ contractAddress, /**
+     * Storage slot of the underlying note.
+     */ storageSlot, /**
+     * Type identifier for the underlying note, required to determine how to compute its hash and nullifier.
+     */ noteTypeId, /**
+     * Note values delivered encrypted.
+     * @dev Note that to recreate the correct note we need to merge privateNoteValues and publicNoteValues. To do that
+     * we need access to the contract ABI (that is done in the NoteProcessor).
+     */ privateNoteValues, /**
+     * Note values delivered in plaintext.
+     * @dev Note that to recreate the correct note we need to merge privateNoteValues and publicNoteValues. To do that
+     * we need access to the contract ABI (that is done in the NoteProcessor).
+     */ publicNoteValues){
+        this.contractAddress = contractAddress;
+        this.storageSlot = storageSlot;
+        this.noteTypeId = noteTypeId;
+        this.privateNoteValues = privateNoteValues;
+        this.publicNoteValues = publicNoteValues;
+    }
+    static fromIncomingBodyPlaintextContractAndPublicValues(plaintext, contractAddress, publicNoteValues) {
+        try {
+            const reader = BufferReader.asReader(plaintext);
+            const fields = reader.readArray(plaintext.length / Fr.SIZE_IN_BYTES, Fr);
+            const storageSlot = fields[0];
+            const noteTypeId = NoteSelector.fromField(fields[1]);
+            const privateNoteValues = fields.slice(2);
+            return new L1NotePayload(contractAddress, storageSlot, noteTypeId, privateNoteValues, publicNoteValues);
+        } catch (e) {
+            return undefined;
+        }
+    }
+    static async decryptAsIncoming(log, sk) {
+        const decryptedLog = await EncryptedLogPayload.decryptAsIncoming(log.fields, sk);
+        if (!decryptedLog) {
+            return undefined;
+        }
+        return this.fromIncomingBodyPlaintextContractAndPublicValues(decryptedLog.incomingBodyPlaintext, decryptedLog.contractAddress, /* publicValues */ []);
+    }
+    static async decryptAsIncomingFromPublic(log, sk) {
+        const { privateValues, publicValues } = parseLogFromPublic(log);
+        if (!privateValues) {
+            return undefined;
+        }
+        const decryptedLog = await EncryptedLogPayload.decryptAsIncoming(privateValues, sk);
+        if (!decryptedLog) {
+            return undefined;
+        }
+        return this.fromIncomingBodyPlaintextContractAndPublicValues(decryptedLog.incomingBodyPlaintext, decryptedLog.contractAddress, publicValues);
+    }
+    /**
+   * Serializes the L1NotePayload object into a Buffer.
+   * @returns Buffer representation of the L1NotePayload object.
+   */ toIncomingBodyPlaintext() {
+        const fields = [
+            this.storageSlot,
+            this.noteTypeId.toField(),
+            ...this.privateNoteValues
+        ];
+        return serializeToBuffer(fields);
+    }
+    /**
+   * Create a random L1NotePayload object (useful for testing purposes).
+   * @param contract - The address of a contract the note was emitted from.
+   * @returns A random L1NotePayload object.
+   */ static async random(contract) {
+        const numPrivateNoteValues = randomInt(2) + 1;
+        const privateNoteValues = Array.from({
+            length: numPrivateNoteValues
+        }, ()=>Fr.random());
+        const numPublicNoteValues = randomInt(2) + 1;
+        const publicNoteValues = Array.from({
+            length: numPublicNoteValues
+        }, ()=>Fr.random());
+        return new L1NotePayload(contract ?? await AztecAddress.random(), Fr.random(), NoteSelector.random(), privateNoteValues, publicNoteValues);
+    }
+    equals(other) {
+        return this.contractAddress.equals(other.contractAddress) && this.storageSlot.equals(other.storageSlot) && this.noteTypeId.equals(other.noteTypeId) && this.privateNoteValues.every((value, index)=>value.equals(other.privateNoteValues[index])) && this.publicNoteValues.every((value, index)=>value.equals(other.publicNoteValues[index]));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.contractAddress, this.storageSlot, this.noteTypeId, new Vector(this.privateNoteValues), new Vector(this.publicNoteValues));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new L1NotePayload(reader.readObject(AztecAddress), reader.readObject(Fr), reader.readObject(NoteSelector), reader.readVector(Fr), reader.readVector(Fr));
+    }
+}
+/**
+ * Parse the given log into an array of public values and an encrypted log.
+ *
+ * @param log - Log to be parsed.
+ * @returns An object containing the public values, encrypted log, and ciphertext length.
+ */ function parseLogFromPublic(log) {
+    // Extract lengths from the log
+    // See aztec_nr/aztec/src/macros/note/mod.nr to see how the "finalization_log" is encoded.
+    // Each length is stored in 2 bytes with a 0 separator byte between them:
+    // [ publicLen[0], publicLen[1], 0, privateLen[0], privateLen[1] ]
+    // Search the codebase for "disgusting encoding" to see other hardcoded instances of this encoding, that you might need to change if you ever find yourself here.
+    const lengths = log.log[0].toBuffer().subarray(-5);
+    const publicValuesLength = lengths.readUint16BE();
+    const privateValuesLength = lengths.readUint16BE(3);
+    // Now we get the fields corresponding to the values generated from private.
+    // Note: +1 for the length values in position 0
+    const privateValues = log.log.slice(1, 1 + privateValuesLength);
+    // At last we load the public values
+    const publicValues = log.log.slice(1 + privateValuesLength, 1 + privateValuesLength + publicValuesLength);
+    return {
+        publicValues,
+        privateValues
+    };
+}

package/dest/logs/l1_payload/payload.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { Vector } from '../../types/index.js';
+/**
+ * The Note class represents a Note emitted from a Noir contract as a vector of Fr (finite field) elements.
+ * This data also represents a preimage to a note hash. This class extends the Vector class, which allows for
+ * additional operations on the underlying field elements.
+ */
+export declare class Payload extends Vector<Fr> {
+    toJSON(): Buffer;
+    static get schema(): import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Buffer, string>, import("zod").ZodEffects<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"Buffer">;
+        data: import("zod").ZodArray<import("zod").ZodNumber, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "Buffer";
+        data: number[];
+    }, {
+        type: "Buffer";
+        data: number[];
+    }>, Buffer, {
+        type: "Buffer";
+        data: number[];
+    }>]>, Payload, string | {
+        type: "Buffer";
+        data: number[];
+    }>;
+    /**
+     * Create a Note instance from a Buffer or BufferReader.
+     * The input 'buffer' can be either a Buffer containing the serialized Fr elements or a BufferReader instance.
+     * This function reads the Fr elements in the buffer and constructs a Note with them.
+     *
+     * @param buffer - The Buffer or BufferReader containing the serialized Fr elements.
+     * @returns A Note instance containing the deserialized Fr elements.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): Payload;
+    /**
+     * Generates a random Note instance with a variable number of items.
+     * The number of items is determined by a random value between 1 and 10 (inclusive).
+     * Each item in the Note is generated using the Fr.random() method.
+     *
+     * @returns A randomly generated Note instance.
+     */
+    static random(): Payload;
+    /**
+     * Returns a hex representation of the note.
+     * @returns A hex string with the vector length as first element.
+     */
+    toString(): `0x${string}`;
+    /**
+     * Creates a new Note instance from a hex string.
+     * @param str - Hex representation.
+     * @returns A Note instance.
+     */
+    static fromString(str: string): Payload;
+    get length(): number;
+    equals(other: Payload): boolean;
+}
+//# sourceMappingURL=payload.d.ts.map

package/dest/logs/l1_payload/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/logs/l1_payload/payload.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAI3D,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C;;;;GAIG;AACH,qBAAa,OAAQ,SAAQ,MAAM,CAAC,EAAE,CAAC;IACrC,MAAM;IAIN,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;OAEhB;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C;;;;;;OAMG;IACH,MAAM,CAAC,MAAM;IAMb;;;OAGG;IACM,QAAQ;IAIjB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM;IAI7B,IAAI,MAAM,WAET;IAED,MAAM,CAAC,KAAK,EAAE,OAAO;CAGtB"}

package/dest/logs/l1_payload/payload.js

@@ -0,0 +1,61 @@
+import { randomInt } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { schemas } from '../../schemas/index.js';
+import { Vector } from '../../types/index.js';
+/**
+ * The Note class represents a Note emitted from a Noir contract as a vector of Fr (finite field) elements.
+ * This data also represents a preimage to a note hash. This class extends the Vector class, which allows for
+ * additional operations on the underlying field elements.
+ */ export class Payload extends Vector {
+    toJSON() {
+        return this.toBuffer();
+    }
+    static get schema() {
+        return schemas.Buffer.transform(Payload.fromBuffer);
+    }
+    /**
+   * Create a Note instance from a Buffer or BufferReader.
+   * The input 'buffer' can be either a Buffer containing the serialized Fr elements or a BufferReader instance.
+   * This function reads the Fr elements in the buffer and constructs a Note with them.
+   *
+   * @param buffer - The Buffer or BufferReader containing the serialized Fr elements.
+   * @returns A Note instance containing the deserialized Fr elements.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new Payload(reader.readVector(Fr));
+    }
+    /**
+   * Generates a random Note instance with a variable number of items.
+   * The number of items is determined by a random value between 1 and 10 (inclusive).
+   * Each item in the Note is generated using the Fr.random() method.
+   *
+   * @returns A randomly generated Note instance.
+   */ static random() {
+        const numItems = randomInt(10) + 1;
+        const items = Array.from({
+            length: numItems
+        }, ()=>Fr.random());
+        return new Payload(items);
+    }
+    /**
+   * Returns a hex representation of the note.
+   * @returns A hex string with the vector length as first element.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Creates a new Note instance from a hex string.
+   * @param str - Hex representation.
+   * @returns A Note instance.
+   */ static fromString(str) {
+        return Payload.fromBuffer(hexToBuffer(str));
+    }
+    get length() {
+        return this.items.length;
+    }
+    equals(other) {
+        return this.items.every((item, index)=>item.equals(other.items[index]));
+    }
+}

package/dest/logs/l1_payload/shared_secret_derivation.d.ts

@@ -0,0 +1,16 @@
+import type { GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import type { AztecAddress } from '../../aztec-address/index.js';
+import type { PublicKey } from '../../keys/public_key.js';
+/**
+ * Derive an Elliptic Curve Diffie-Hellman (ECDH) Shared Secret.
+ * The function takes in an ECDH public key, a private key, and a Grumpkin instance to compute
+ * the shared secret.
+ *
+ * @param secretKey - The secret key used to derive shared secret.
+ * @param publicKey - The public key used to derive shared secret.
+ * @returns A derived shared secret.
+ * @throws If the publicKey is zero.
+ */
+export declare function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point>;
+export declare function deriveEcdhSharedSecretUsingAztecAddress(secretKey: GrumpkinScalar, address: AztecAddress): Promise<Point>;
+//# sourceMappingURL=shared_secret_derivation.d.ts.map

package/dest/logs/l1_payload/shared_secret_derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared_secret_derivation.d.ts","sourceRoot":"","sources":["../../../src/logs/l1_payload/shared_secret_derivation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAS5G;AAED,wBAAsB,uCAAuC,CAC3D,SAAS,EAAE,cAAc,EACzB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,KAAK,CAAC,CAIhB"}

package/dest/logs/l1_payload/shared_secret_derivation.js

@@ -0,0 +1,23 @@
+import { Grumpkin } from '@aztec/foundation/crypto';
+/**
+ * Derive an Elliptic Curve Diffie-Hellman (ECDH) Shared Secret.
+ * The function takes in an ECDH public key, a private key, and a Grumpkin instance to compute
+ * the shared secret.
+ *
+ * @param secretKey - The secret key used to derive shared secret.
+ * @param publicKey - The public key used to derive shared secret.
+ * @returns A derived shared secret.
+ * @throws If the publicKey is zero.
+ */ export async function deriveEcdhSharedSecret(secretKey, publicKey) {
+    if (publicKey.isZero()) {
+        throw new Error(`Attempting to derive a shared secret with a zero public key. You have probably passed a zero public key in your Noir code somewhere thinking that the note won't be broadcast... but it was.`);
+    }
+    const curve = new Grumpkin();
+    const sharedSecret = await curve.mul(publicKey, secretKey);
+    return sharedSecret;
+}
+export async function deriveEcdhSharedSecretUsingAztecAddress(secretKey, address) {
+    const addressPoint = await address.toAddressPoint();
+    const sharedSecret = await deriveEcdhSharedSecret(secretKey, addressPoint);
+    return sharedSecret;
+}

package/dest/logs/log_filter.d.ts

@@ -0,0 +1,22 @@
+import type { AztecAddress } from '../aztec-address/index.js';
+import { type ZodFor } from '../schemas/index.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { LogId } from './log_id.js';
+/**
+ * Log filter used to fetch L2 logs.
+ * @remarks This filter is applied as an intersection of all it's params.
+ */
+export type LogFilter = {
+    /** Hash of a transaction from which to fetch the logs. */
+    txHash?: TxHash;
+    /** The block number from which to start fetching logs (inclusive). */
+    fromBlock?: number;
+    /** The block number until which to fetch logs (not inclusive). */
+    toBlock?: number;
+    /** Log id after which to start fetching logs. */
+    afterLog?: LogId;
+    /** The contract address to filter logs by. */
+    contractAddress?: AztecAddress;
+};
+export declare const LogFilterSchema: ZodFor<LogFilter>;
+//# sourceMappingURL=log_filter.d.ts.map

package/dest/logs/log_filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log_filter.d.ts","sourceRoot":"","sources":["../../src/logs/log_filter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,8CAA8C;IAC9C,eAAe,CAAC,EAAE,YAAY,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,SAAS,CAM5C,CAAC"}

package/dest/logs/log_filter.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { schemas } from '../schemas/index.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { LogId } from './log_id.js';
+export const LogFilterSchema = z.object({
+    txHash: TxHash.schema.optional(),
+    fromBlock: schemas.Integer.optional(),
+    toBlock: schemas.Integer.optional(),
+    afterLog: LogId.schema.optional(),
+    contractAddress: schemas.AztecAddress.optional()
+});

package/dest/logs/log_id.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+/** A globally unique log id. */
+export declare class LogId {
+    /** The block number the log was emitted in. */
+    readonly blockNumber: number;
+    /** The index of a tx in a block the log was emitted in. */
+    readonly txIndex: number;
+    /** The index of a log the tx was emitted in. */
+    readonly logIndex: number;
+    /**
+     * Parses a log id from a string.
+     * @param blockNumber - The block number.
+     * @param txIndex - The transaction index.
+     * @param logIndex - The log index.
+     */
+    constructor(
+    /** The block number the log was emitted in. */
+    blockNumber: number, 
+    /** The index of a tx in a block the log was emitted in. */
+    txIndex: number, 
+    /** The index of a log the tx was emitted in. */
+    logIndex: number);
+    static random(): LogId;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        blockNumber: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        txIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        logIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        blockNumber: number;
+        txIndex: number;
+        logIndex: number;
+    }, {
+        blockNumber: string | number | bigint;
+        txIndex: string | number | bigint;
+        logIndex: string | number | bigint;
+    }>, LogId, {
+        blockNumber: string | number | bigint;
+        txIndex: string | number | bigint;
+        logIndex: string | number | bigint;
+    }>;
+    /**
+     * Serializes log id to a buffer.
+     * @returns A buffer containing the serialized log id.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Creates a LogId from a buffer.
+     * @param buffer - A buffer containing the serialized log id.
+     * @returns A log id.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): LogId;
+    /**
+     * Converts the LogId instance to a string.
+     * @returns A string representation of the log id.
+     */
+    toString(): string;
+    /**
+     * Creates a LogId from a string.
+     * @param data - A string representation of a log id.
+     * @returns A log id.
+     */
+    static fromString(data: string): LogId;
+    /**
+     * Serializes log id to a human readable string.
+     * @returns A human readable representation of the log id.
+     */
+    toHumanReadable(): string;
+}
+//# sourceMappingURL=log_id.d.ts.map

package/dest/logs/log_id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log_id.d.ts","sourceRoot":"","sources":["../../src/logs/log_id.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,gCAAgC;AAChC,qBAAa,KAAK;IAQd,+CAA+C;aAC/B,WAAW,EAAE,MAAM;IACnC,2DAA2D;aAC3C,OAAO,EAAE,MAAM;IAC/B,gDAAgD;aAChC,QAAQ,EAAE,MAAM;IAZlC;;;;;OAKG;;IAED,+CAA+C;IAC/B,WAAW,EAAE,MAAM;IACnC,2DAA2D;IAC3C,OAAO,EAAE,MAAM;IAC/B,gDAAgD;IAChC,QAAQ,EAAE,MAAM;IAalC,MAAM,CAAC,MAAM;IAQb,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;OAQhB;IAED;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAQzB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,KAAK;IAUvD;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAStC;;;OAGG;IACI,eAAe,IAAI,MAAM;CAGjC"}

package/dest/logs/log_id.js

@@ -0,0 +1,83 @@
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { schemas } from '../schemas/index.js';
+/** A globally unique log id. */ export class LogId {
+    blockNumber;
+    txIndex;
+    logIndex;
+    /**
+   * Parses a log id from a string.
+   * @param blockNumber - The block number.
+   * @param txIndex - The transaction index.
+   * @param logIndex - The log index.
+   */ constructor(/** The block number the log was emitted in. */ blockNumber, /** The index of a tx in a block the log was emitted in. */ txIndex, /** The index of a log the tx was emitted in. */ logIndex){
+        this.blockNumber = blockNumber;
+        this.txIndex = txIndex;
+        this.logIndex = logIndex;
+        if (!Number.isInteger(blockNumber) || blockNumber < INITIAL_L2_BLOCK_NUM) {
+            throw new Error(`Invalid block number: ${blockNumber}`);
+        }
+        if (!Number.isInteger(txIndex)) {
+            throw new Error(`Invalid tx index: ${txIndex}`);
+        }
+        if (!Number.isInteger(logIndex)) {
+            throw new Error(`Invalid log index: ${logIndex}`);
+        }
+    }
+    static random() {
+        return new LogId(Math.floor(Math.random() * 1000) + 1, Math.floor(Math.random() * 1000), Math.floor(Math.random() * 100));
+    }
+    static get schema() {
+        return z.object({
+            blockNumber: schemas.Integer,
+            txIndex: schemas.Integer,
+            logIndex: schemas.Integer
+        }).transform(({ blockNumber, txIndex, logIndex })=>new LogId(blockNumber, txIndex, logIndex));
+    }
+    /**
+   * Serializes log id to a buffer.
+   * @returns A buffer containing the serialized log id.
+   */ toBuffer() {
+        return Buffer.concat([
+            toBufferBE(BigInt(this.blockNumber), 4),
+            toBufferBE(BigInt(this.txIndex), 4),
+            toBufferBE(BigInt(this.logIndex), 4)
+        ]);
+    }
+    /**
+   * Creates a LogId from a buffer.
+   * @param buffer - A buffer containing the serialized log id.
+   * @returns A log id.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const blockNumber = reader.readNumber();
+        const txIndex = reader.readNumber();
+        const logIndex = reader.readNumber();
+        return new LogId(blockNumber, txIndex, logIndex);
+    }
+    /**
+   * Converts the LogId instance to a string.
+   * @returns A string representation of the log id.
+   */ toString() {
+        return `${this.blockNumber}-${this.txIndex}-${this.logIndex}`;
+    }
+    /**
+   * Creates a LogId from a string.
+   * @param data - A string representation of a log id.
+   * @returns A log id.
+   */ static fromString(data) {
+        const [rawBlockNumber, rawTxIndex, rawLogIndex] = data.split('-');
+        const blockNumber = Number(rawBlockNumber);
+        const txIndex = Number(rawTxIndex);
+        const logIndex = Number(rawLogIndex);
+        return new LogId(blockNumber, txIndex, logIndex);
+    }
+    /**
+   * Serializes log id to a human readable string.
+   * @returns A human readable representation of the log id.
+   */ toHumanReadable() {
+        return `logId: (blockNumber: ${this.blockNumber}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
+    }
+}

package/dest/logs/log_with_tx_data.d.ts

@@ -0,0 +1,11 @@
+import { Fr } from '@aztec/foundation/fields';
+export declare class LogWithTxData {
+    logContent: Fr[];
+    txHash: Fr;
+    uniqueNoteHashesInTx: Fr[];
+    firstNullifierInTx: Fr;
+    constructor(logContent: Fr[], txHash: Fr, uniqueNoteHashesInTx: Fr[], firstNullifierInTx: Fr);
+    toNoirSerialization(): (Fr | Fr[])[];
+    static noirSerializationOfEmpty(): (Fr | Fr[])[];
+}
+//# sourceMappingURL=log_with_tx_data.d.ts.map

package/dest/logs/log_with_tx_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log_with_tx_data.d.ts","sourceRoot":"","sources":["../../src/logs/log_with_tx_data.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,qBAAa,aAAa;IAEf,UAAU,EAAE,EAAE,EAAE;IAChB,MAAM,EAAE,EAAE;IACV,oBAAoB,EAAE,EAAE,EAAE;IAC1B,kBAAkB,EAAE,EAAE;gBAHtB,UAAU,EAAE,EAAE,EAAE,EAChB,MAAM,EAAE,EAAE,EACV,oBAAoB,EAAE,EAAE,EAAE,EAC1B,kBAAkB,EAAE,EAAE;IAG/B,mBAAmB,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE;IASpC,MAAM,CAAC,wBAAwB,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE;CAGjD"}

package/dest/logs/log_with_tx_data.js

@@ -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 {
+    logContent;
+    txHash;
+    uniqueNoteHashesInTx;
+    firstNullifierInTx;
+    constructor(logContent, txHash, uniqueNoteHashesInTx, firstNullifierInTx){
+        this.logContent = logContent;
+        this.txHash = txHash;
+        this.uniqueNoteHashesInTx = uniqueNoteHashesInTx;
+        this.firstNullifierInTx = firstNullifierInTx;
+    }
+    toNoirSerialization() {
+        return [
+            ...toBoundedVecSerialization(this.logContent, PUBLIC_LOG_DATA_SIZE_IN_FIELDS),
+            this.txHash,
+            ...toBoundedVecSerialization(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
+            this.firstNullifierInTx
+        ];
+    }
+    static noirSerializationOfEmpty() {
+        return new LogWithTxData([], new Fr(0), [], new Fr(0)).toNoirSerialization();
+    }
+}
+function toBoundedVecSerialization(array, maxLength) {
+    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)
+    ];
+}