@aztec/stdlib 0.0.0-test.0

package/dest/logs/l1_payload/encrypted_log_payload.js

@@ -0,0 +1,140 @@
+import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { Fr, NotOnCurveError, Point } from '@aztec/foundation/fields';
+import { BufferReader, numToUInt16BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { AztecAddress } from '../../aztec-address/index.js';
+import { derivePublicKeyFromSecretKey } from '../../keys/derivation.js';
+import { PrivateLog } from '../private_log.js';
+import { aes128Decrypt, aes128Encrypt, deriveAesSymmetricKeyAndIvFromEcdhSharedSecretUsingSha256 } from './encryption_util.js';
+import { deriveEcdhSharedSecret, deriveEcdhSharedSecretUsingAztecAddress } from './shared_secret_derivation.js';
+// Below constants should match the values defined in aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/note.nr.
+// Note: we will soon be 'abstracting' log processing: apps will process their own logs, instead of the PXE processing all apps' logs. Therefore, this file will imminently change considerably.
+const TAG_SIZE_IN_FIELDS = 1;
+const EPK_SIZE_IN_FIELDS = 1;
+const USABLE_PRIVATE_LOG_SIZE_IN_FIELDS = PRIVATE_LOG_SIZE_IN_FIELDS - TAG_SIZE_IN_FIELDS - EPK_SIZE_IN_FIELDS;
+const USABLE_PRIVATE_LOG_SIZE_IN_BYTES = USABLE_PRIVATE_LOG_SIZE_IN_FIELDS * 31 / 16 * 16;
+// The incoming header ciphertext is 48 bytes
+// 32 bytes for the address, and 16 bytes padding to follow PKCS#7
+const HEADER_CIPHERTEXT_SIZE_IN_BYTES = 48;
+const USABLE_PLAINTEXT_SIZE_IN_BYTES = USABLE_PRIVATE_LOG_SIZE_IN_BYTES - HEADER_CIPHERTEXT_SIZE_IN_BYTES;
+const CONTRACT_ADDRESS_SIZE_IN_BYTES = 32;
+const SIZE_OF_ENCODING_OF_CIPHERTEXT_SIZE_IN_BYTES = 2;
+function beBytes31ToFields(bytes) {
+    const fields = [];
+    const numFields = Math.ceil(bytes.length / 31);
+    for(let i = 0; i < numFields; i++){
+        fields.push(new Fr(bytes.subarray(i * 31, (i + 1) * 31)));
+    }
+    return fields;
+}
+function fieldsToBEBytes31(fields) {
+    return Buffer.concat(fields.map((f)=>f.toBuffer().subarray(1)));
+}
+/**
+ * Encrypted log payload with a tag used for retrieval by clients.
+ */ export class EncryptedLogPayload {
+    tag;
+    contractAddress;
+    incomingBodyPlaintext;
+    constructor(/**
+     * Note discovery tag.
+     */ tag, /**
+     * Address of a contract that emitted the log.
+     */ contractAddress, /**
+     * Decrypted incoming body.
+     */ incomingBodyPlaintext){
+        this.tag = tag;
+        this.contractAddress = contractAddress;
+        this.incomingBodyPlaintext = incomingBodyPlaintext;
+    }
+    // NB: Only appears to be used in tests
+    // See noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/note.nr
+    async generatePayload(ephSk, recipient, rand = randomBytes) {
+        const ephPk = await derivePublicKeyFromSecretKey(ephSk);
+        const [ephPkX, ephPkSignBool] = ephPk.toXAndSign();
+        const ephPkSignU8 = Buffer.from([
+            Number(ephPkSignBool)
+        ]);
+        const ciphertextSharedSecret = await deriveEcdhSharedSecretUsingAztecAddress(ephSk, recipient); // not to be confused with the tagging shared secret
+        const [symKey, iv] = deriveAesSymmetricKeyAndIvFromEcdhSharedSecretUsingSha256(ciphertextSharedSecret);
+        if (this.incomingBodyPlaintext.length > USABLE_PLAINTEXT_SIZE_IN_BYTES) {
+            throw new Error(`Incoming body plaintext cannot be more than ${USABLE_PLAINTEXT_SIZE_IN_BYTES} bytes.`);
+        }
+        const finalPlaintext = this.incomingBodyPlaintext;
+        const ciphertextBytes = await aes128Encrypt(finalPlaintext, iv, symKey);
+        const headerPlaintext = serializeToBuffer(this.contractAddress.toBuffer(), numToUInt16BE(ciphertextBytes.length));
+        // TODO: it is unsafe to re-use the same iv and symKey. We'll need to do something cleverer.
+        const headerCiphertextBytes = await aes128Encrypt(headerPlaintext, iv, symKey);
+        if (headerCiphertextBytes.length !== HEADER_CIPHERTEXT_SIZE_IN_BYTES) {
+            throw new Error(`Invalid header ciphertext size: ${headerCiphertextBytes.length}`);
+        }
+        const properLogBytesLength = 1 /* ephPkSignU8 */  + HEADER_CIPHERTEXT_SIZE_IN_BYTES + ciphertextBytes.length;
+        const logBytesPaddingToMult31 = rand(31 * Math.ceil(properLogBytesLength / 31) - properLogBytesLength);
+        const logBytes = serializeToBuffer(ephPkSignU8, headerCiphertextBytes, ciphertextBytes, logBytesPaddingToMult31);
+        if (logBytes.length % 31 !== 0) {
+            throw new Error(`logBytes.length should be divisible by 31, got: ${logBytes.length}`);
+        }
+        const fieldsPadding = Array.from({
+            length: USABLE_PRIVATE_LOG_SIZE_IN_FIELDS - logBytes.length / 31
+        }, ()=>Fr.fromBuffer(rand(32))); // we use the randomBytes function instead of `Fr.random()`, so that we can use deterministic randomness in tests, through the rand() function.
+        const logFields = [
+            this.tag,
+            ephPkX,
+            ...beBytes31ToFields(logBytes),
+            ...fieldsPadding
+        ];
+        if (logFields.length !== PRIVATE_LOG_SIZE_IN_FIELDS) {
+            throw new Error(`Expected private log payload to have ${PRIVATE_LOG_SIZE_IN_FIELDS} fields. Got ${logFields.length}.`);
+        }
+        return new PrivateLog(logFields);
+    }
+    /**
+   * Decrypts a ciphertext as an incoming log.
+   *
+   * This is executable by the recipient of the note, and uses the addressSecret to decrypt the payload.
+   *
+   * @param payload - The payload for the log
+   * @param addressSecret - The address secret, used to decrypt the logs
+   * @param ciphertextLength - Optionally supply the ciphertext length (see trimCiphertext())
+   * @returns The decrypted log payload
+   */ static async decryptAsIncoming(payload, addressSecret) {
+        try {
+            const logFields = payload;
+            const tag = logFields[0];
+            const ephPkX = logFields[1];
+            const reader = BufferReader.asReader(fieldsToBEBytes31(logFields.slice(TAG_SIZE_IN_FIELDS + EPK_SIZE_IN_FIELDS)));
+            const ephPkSigBuf = reader.readBytes(1);
+            const ephPkSignBool = !!ephPkSigBuf[0];
+            const ephPk = await Point.fromXAndSign(ephPkX, ephPkSignBool);
+            const headerCiphertextBytes = reader.readBytes(HEADER_CIPHERTEXT_SIZE_IN_BYTES);
+            let contractAddress = AztecAddress.ZERO;
+            if (!addressSecret) {
+                throw new Error('Cannot decrypt without an address secret.');
+            }
+            const ciphertextSharedSecret = await deriveEcdhSharedSecret(addressSecret, ephPk);
+            const [symKey, iv] = deriveAesSymmetricKeyAndIvFromEcdhSharedSecretUsingSha256(ciphertextSharedSecret);
+            const headerPlaintextBytes = await aes128Decrypt(headerCiphertextBytes, iv, symKey);
+            const headerReader = BufferReader.asReader(headerPlaintextBytes);
+            const contractAddressBuf = headerReader.readBytes(CONTRACT_ADDRESS_SIZE_IN_BYTES);
+            contractAddress = AztecAddress.fromBuffer(contractAddressBuf);
+            const ciphertextBytesLengthBuf = headerReader.readBytes(SIZE_OF_ENCODING_OF_CIPHERTEXT_SIZE_IN_BYTES);
+            const ciphertextBytesLength = (ciphertextBytesLengthBuf[0] << 8) + ciphertextBytesLengthBuf[1];
+            const ciphertextBytes = reader.readBytes(ciphertextBytesLength);
+            const plaintextBytes = await aes128Decrypt(ciphertextBytes, iv, symKey);
+            return new EncryptedLogPayload(tag, contractAddress, plaintextBytes);
+        } catch (e) {
+            // Following error messages are expected to occur when decryption fails
+            if (!this.isAcceptableError(e)) {
+                // If we encounter an unexpected error, we rethrow it
+                throw e;
+            }
+            return;
+        }
+    }
+    static isAcceptableError(e) {
+        return e instanceof NotOnCurveError || e.message.endsWith('is greater or equal to field modulus.') || e.message.startsWith('Invalid AztecAddress length') || e.message.startsWith('Selector must fit in') || e.message.startsWith('Attempted to read beyond buffer length') || e.message.startsWith('RangeError [ERR_BUFFER_OUT_OF_BOUNDS]:');
+    }
+    toBuffer() {
+        return serializeToBuffer(this.tag, this.contractAddress.toBuffer(), this.incomingBodyPlaintext);
+    }
+}

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

@@ -0,0 +1,24 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Point } from '@aztec/foundation/fields';
+export declare function deriveAesSymmetricKeyAndIvFromEcdhSharedSecretUsingSha256(sharedSecret: Point): [Buffer, Buffer];
+/**
+ * Encrypts the plaintext using the secret key and public key
+ *
+ * @param plaintext - The plaintext buffer
+ * @param secret - The secret key used to derive the AES secret
+ * @param publicKey - Public key used to derived the AES secret
+ * @param deriveSecret - Function to derive the AES secret from the ephemeral secret key and public key
+ * @returns The ciphertext
+ */
+export declare function aes128Encrypt(plaintext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer>;
+/**
+ * Decrypts the ciphertext using the secret key and public key
+ * @param ciphertext - The ciphertext buffer
+ * @param secret - The secret key used to derive the AES secret
+ * @param publicKey - The public key used to derive the AES secret
+ * @param deriveSecret - Function to derive the AES secret from the ephemeral secret key and public key
+ * @returns
+ */
+export declare function aes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer>;
+//# sourceMappingURL=encryption_util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encryption_util.d.ts","sourceRoot":"","sources":["../../../src/logs/l1_payload/encryption_util.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAmBtD,wBAAgB,yDAAyD,CAAC,YAAY,EAAE,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAK/G;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG5F;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG7F"}

package/dest/logs/l1_payload/encryption_util.js

@@ -0,0 +1,46 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { Aes128, sha256 } from '@aztec/foundation/crypto';
+import { numToUInt8 } from '@aztec/foundation/serialize';
+function extractCloseToUniformlyRandom256BitsFromEcdhSharedSecretUsingSha256(sharedSecret) {
+    const secretBuffer = Buffer.concat([
+        sharedSecret.toCompressedBuffer(),
+        numToUInt8(GeneratorIndex.SYMMETRIC_KEY)
+    ]);
+    const hash = sha256(secretBuffer);
+    return hash;
+}
+function deriveAesSymmetricKeyAndIvFromEcdhSharedSecret(sharedSecret, randomnessExtractionFunction) {
+    const random256Bits = randomnessExtractionFunction(sharedSecret);
+    const symKey = random256Bits.subarray(0, 16);
+    const iv = random256Bits.subarray(16, 32);
+    return [
+        symKey,
+        iv
+    ];
+}
+export function deriveAesSymmetricKeyAndIvFromEcdhSharedSecretUsingSha256(sharedSecret) {
+    return deriveAesSymmetricKeyAndIvFromEcdhSharedSecret(sharedSecret, extractCloseToUniformlyRandom256BitsFromEcdhSharedSecretUsingSha256);
+}
+/**
+ * Encrypts the plaintext using the secret key and public key
+ *
+ * @param plaintext - The plaintext buffer
+ * @param secret - The secret key used to derive the AES secret
+ * @param publicKey - Public key used to derived the AES secret
+ * @param deriveSecret - Function to derive the AES secret from the ephemeral secret key and public key
+ * @returns The ciphertext
+ */ export function aes128Encrypt(plaintext, iv, symKey) {
+    const aes128 = new Aes128();
+    return aes128.encryptBufferCBC(plaintext, iv, symKey);
+}
+/**
+ * Decrypts the ciphertext using the secret key and public key
+ * @param ciphertext - The ciphertext buffer
+ * @param secret - The secret key used to derive the AES secret
+ * @param publicKey - The public key used to derive the AES secret
+ * @param deriveSecret - Function to derive the AES secret from the ephemeral secret key and public key
+ * @returns
+ */ export function aes128Decrypt(ciphertext, iv, symKey) {
+    const aes128 = new Aes128();
+    return aes128.decryptBufferCBC(ciphertext, iv, symKey);
+}

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

@@ -0,0 +1,3 @@
+export * from './encrypted_log_payload.js';
+export * from './l1_note_payload.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/logs/l1_payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC"}

package/dest/logs/l1_payload/index.js

@@ -0,0 +1,2 @@
+export * from './encrypted_log_payload.js';
+export * from './l1_note_payload.js';

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"}