@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/logs/extended_contract_class_log.js

@@ -0,0 +1,67 @@
+import { BufferReader } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import isEqual from 'lodash.isequal';
+import { z } from 'zod';
+import { ContractClassLog } from './contract_class_log.js';
+import { LogId } from './log_id.js';
+/**
+ * Represents an individual contract class log entry extended with info about the block and tx it was emitted in.
+ */ export class ExtendedContractClassLog {
+    id;
+    log;
+    constructor(/** Globally unique id of the log. */ id, /** The data contents of the log. */ log){
+        this.id = id;
+        this.log = log;
+    }
+    static async random() {
+        return new ExtendedContractClassLog(LogId.random(), await ContractClassLog.random());
+    }
+    static get schema() {
+        return z.object({
+            id: LogId.schema,
+            log: ContractClassLog.schema
+        }).transform(ExtendedContractClassLog.from);
+    }
+    static from(fields) {
+        return new ExtendedContractClassLog(fields.id, fields.log);
+    }
+    /**
+   * Serializes log to a buffer.
+   * @returns A buffer containing the serialized log.
+   */ toBuffer() {
+        return Buffer.concat([
+            this.id.toBuffer(),
+            this.log.toBuffer()
+        ]);
+    }
+    /**
+   * Serializes log to a string.
+   * @returns A string containing the serialized log.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Checks if two ExtendedContractClassLog objects are equal.
+   * @param other - Another ExtendedContractClassLog object to compare with.
+   * @returns True if the two objects are equal, false otherwise.
+   */ equals(other) {
+        return isEqual(this, other);
+    }
+    /**
+   * Deserializes log from a buffer.
+   * @param buffer - The buffer or buffer reader containing the log.
+   * @returns Deserialized instance of `Log`.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const logId = LogId.fromBuffer(reader);
+        const log = ContractClassLog.fromBuffer(reader);
+        return new ExtendedContractClassLog(logId, log);
+    }
+    /**
+   * Deserializes `ExtendedContractClassLog` object from a hex string representation.
+   * @param data - A hex string representation of the log.
+   * @returns An `ExtendedContractClassLog` object.
+   */ static fromString(data) {
+        return ExtendedContractClassLog.fromBuffer(hexToBuffer(data));
+    }
+}

package/dest/logs/extended_public_log.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import { LogId } from './log_id.js';
+import { PublicLog } from './public_log.js';
+/**
+ * Represents an individual public log entry extended with info about the block and tx it was emitted in.
+ */
+export declare class ExtendedPublicLog {
+    /** Globally unique id of the log. */
+    readonly id: LogId;
+    /** The data contents of the log. */
+    readonly log: PublicLog;
+    constructor(
+    /** Globally unique id of the log. */
+    id: LogId, 
+    /** The data contents of the log. */
+    log: PublicLog);
+    static random(): Promise<ExtendedPublicLog>;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        id: 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;
+        }>;
+        log: import("@aztec/foundation/schemas").ZodFor<PublicLog>;
+    }, "strip", z.ZodTypeAny, {
+        id: LogId;
+        log: PublicLog;
+    }, {
+        id: {
+            blockNumber: string | number | bigint;
+            txIndex: string | number | bigint;
+            logIndex: string | number | bigint;
+        };
+        log?: any;
+    }>, ExtendedPublicLog, {
+        id: {
+            blockNumber: string | number | bigint;
+            txIndex: string | number | bigint;
+            logIndex: string | number | bigint;
+        };
+        log?: any;
+    }>;
+    static from(fields: FieldsOf<ExtendedPublicLog>): ExtendedPublicLog;
+    /**
+     * Serializes log to a buffer.
+     * @returns A buffer containing the serialized log.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Serializes log to a string.
+     * @returns A string containing the serialized log.
+     */
+    toString(): string;
+    /**
+     * Serializes log to a human readable string.
+     * @returns A human readable representation of the log.
+     */
+    toHumanReadable(): string;
+    /**
+     * Checks if two ExtendedPublicLog objects are equal.
+     * @param other - Another ExtendedPublicLog object to compare with.
+     * @returns True if the two objects are equal, false otherwise.
+     */
+    equals(other: ExtendedPublicLog): boolean;
+    /**
+     * Deserializes log from a buffer.
+     * @param buffer - The buffer or buffer reader containing the log.
+     * @returns Deserialized instance of `Log`.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): ExtendedPublicLog;
+    /**
+     * Deserializes `ExtendedPublicLog` object from a hex string representation.
+     * @param data - A hex string representation of the log.
+     * @returns An `ExtendedPublicLog` object.
+     */
+    static fromString(data: string): ExtendedPublicLog;
+}
+//# sourceMappingURL=extended_public_log.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extended_public_log.d.ts","sourceRoot":"","sources":["../../src/logs/extended_public_log.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,qBAAa,iBAAiB;IAE1B,qCAAqC;aACrB,EAAE,EAAE,KAAK;IACzB,oCAAoC;aACpB,GAAG,EAAE,SAAS;;IAH9B,qCAAqC;IACrB,EAAE,EAAE,KAAK;IACzB,oCAAoC;IACpB,GAAG,EAAE,SAAS;WAGnB,MAAM;IAInB,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC;IAI/C;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;OAGG;IACI,eAAe,IAAI,MAAM;IAIhC;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO;IAIhD;;;;OAIG;WACW,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,iBAAiB;IAS1E;;;;OAIG;WACW,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB;CAG1D"}

package/dest/logs/extended_public_log.js

@@ -0,0 +1,73 @@
+import { BufferReader } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import isEqual from 'lodash.isequal';
+import { z } from 'zod';
+import { LogId } from './log_id.js';
+import { PublicLog } from './public_log.js';
+/**
+ * Represents an individual public log entry extended with info about the block and tx it was emitted in.
+ */ export class ExtendedPublicLog {
+    id;
+    log;
+    constructor(/** Globally unique id of the log. */ id, /** The data contents of the log. */ log){
+        this.id = id;
+        this.log = log;
+    }
+    static async random() {
+        return new ExtendedPublicLog(LogId.random(), await PublicLog.random());
+    }
+    static get schema() {
+        return z.object({
+            id: LogId.schema,
+            log: PublicLog.schema
+        }).transform(ExtendedPublicLog.from);
+    }
+    static from(fields) {
+        return new ExtendedPublicLog(fields.id, fields.log);
+    }
+    /**
+   * Serializes log to a buffer.
+   * @returns A buffer containing the serialized log.
+   */ toBuffer() {
+        return Buffer.concat([
+            this.id.toBuffer(),
+            this.log.toBuffer()
+        ]);
+    }
+    /**
+   * Serializes log to a string.
+   * @returns A string containing the serialized log.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Serializes log to a human readable string.
+   * @returns A human readable representation of the log.
+   */ toHumanReadable() {
+        return `${this.id.toHumanReadable()}, ${this.log.toHumanReadable()}`;
+    }
+    /**
+   * Checks if two ExtendedPublicLog objects are equal.
+   * @param other - Another ExtendedPublicLog object to compare with.
+   * @returns True if the two objects are equal, false otherwise.
+   */ equals(other) {
+        return isEqual(this, other);
+    }
+    /**
+   * Deserializes log from a buffer.
+   * @param buffer - The buffer or buffer reader containing the log.
+   * @returns Deserialized instance of `Log`.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const logId = LogId.fromBuffer(reader);
+        const log = PublicLog.fromBuffer(reader);
+        return new ExtendedPublicLog(logId, log);
+    }
+    /**
+   * Deserializes `ExtendedPublicLog` object from a hex string representation.
+   * @param data - A hex string representation of the log.
+   * @returns An `ExtendedPublicLog` object.
+   */ static fromString(data) {
+        return ExtendedPublicLog.fromBuffer(hexToBuffer(data));
+    }
+}

package/dest/logs/index.d.ts

@@ -0,0 +1,12 @@
+export * from './log_with_tx_data.js';
+export * from './indexed_tagging_secret.js';
+export * from './contract_class_log.js';
+export * from './public_log.js';
+export * from './private_log.js';
+export * from './log_id.js';
+export * from './log_filter.js';
+export * from './extended_public_log.js';
+export * from './extended_contract_class_log.js';
+export * from './l1_payload/index.js';
+export * from './tx_scoped_l2_log.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logs/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

package/dest/logs/index.js

@@ -0,0 +1,11 @@
+export * from './log_with_tx_data.js';
+export * from './indexed_tagging_secret.js';
+export * from './contract_class_log.js';
+export * from './public_log.js';
+export * from './private_log.js';
+export * from './log_id.js';
+export * from './log_filter.js';
+export * from './extended_public_log.js';
+export * from './extended_contract_class_log.js';
+export * from './l1_payload/index.js';
+export * from './tx_scoped_l2_log.js';

package/dest/logs/indexed_tagging_secret.d.ts

@@ -0,0 +1,28 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '../aztec-address/index.js';
+export declare class IndexedTaggingSecret {
+    appTaggingSecret: Fr;
+    index: number;
+    constructor(appTaggingSecret: Fr, index: number);
+    toFields(): Fr[];
+    static fromFields(serialized: Fr[]): IndexedTaggingSecret;
+    /**
+     * Computes the tag based on the app tagging secret, recipient and index.
+     * @dev By including the recipient we achieve "directionality" of the tag (when sending a note in the other
+     * direction, the tag will be different).
+     * @param recipient The recipient of the note
+     * @returns The tag.
+     */
+    computeTag(recipient: AztecAddress): Promise<Fr>;
+    /**
+     * Computes the siloed tag.
+     * @dev We do this second layer of siloing (one was already done as the tagging secret is app-siloed) because kernels
+     * do that to protect against contract impersonation attacks. This extra layer of siloing in kernels ensures that
+     * a malicious contract cannot emit a note with a tag corresponding to another contract.
+     * @param recipient The recipient of the note
+     * @param app The app address
+     * @returns The siloed tag.
+     */
+    computeSiloedTag(recipient: AztecAddress, app: AztecAddress): Promise<Fr>;
+}
+//# sourceMappingURL=indexed_tagging_secret.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexed_tagging_secret.d.ts","sourceRoot":"","sources":["../../src/logs/indexed_tagging_secret.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,qBAAa,oBAAoB;IACZ,gBAAgB,EAAE,EAAE;IAAS,KAAK,EAAE,MAAM;gBAA1C,gBAAgB,EAAE,EAAE,EAAS,KAAK,EAAE,MAAM;IAM7D,QAAQ,IAAI,EAAE,EAAE;IAIhB,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,EAAE,EAAE;IAIlC;;;;;;OAMG;IACH,UAAU,CAAC,SAAS,EAAE,YAAY;IAIlC;;;;;;;;OAQG;IACG,gBAAgB,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY;CAIlE"}

package/dest/logs/indexed_tagging_secret.js

@@ -0,0 +1,50 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+export class IndexedTaggingSecret {
+    appTaggingSecret;
+    index;
+    constructor(appTaggingSecret, index){
+        this.appTaggingSecret = appTaggingSecret;
+        this.index = index;
+        if (index < 0) {
+            throw new Error('IndexedTaggingSecret index out of bounds');
+        }
+    }
+    toFields() {
+        return [
+            this.appTaggingSecret,
+            new Fr(this.index)
+        ];
+    }
+    static fromFields(serialized) {
+        return new this(serialized[0], serialized[1].toNumber());
+    }
+    /**
+   * Computes the tag based on the app tagging secret, recipient and index.
+   * @dev By including the recipient we achieve "directionality" of the tag (when sending a note in the other
+   * direction, the tag will be different).
+   * @param recipient The recipient of the note
+   * @returns The tag.
+   */ computeTag(recipient) {
+        return poseidon2Hash([
+            this.appTaggingSecret,
+            recipient,
+            this.index
+        ]);
+    }
+    /**
+   * Computes the siloed tag.
+   * @dev We do this second layer of siloing (one was already done as the tagging secret is app-siloed) because kernels
+   * do that to protect against contract impersonation attacks. This extra layer of siloing in kernels ensures that
+   * a malicious contract cannot emit a note with a tag corresponding to another contract.
+   * @param recipient The recipient of the note
+   * @param app The app address
+   * @returns The siloed tag.
+   */ async computeSiloedTag(recipient, app) {
+        const tag = await this.computeTag(recipient);
+        return poseidon2Hash([
+            app,
+            tag
+        ]);
+    }
+}

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

@@ -0,0 +1,50 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr, type GrumpkinScalar } from '@aztec/foundation/fields';
+import { AztecAddress } from '../../aztec-address/index.js';
+import { PrivateLog } from '../private_log.js';
+/**
+ * Encrypted log payload with a tag used for retrieval by clients.
+ */
+export declare class EncryptedLogPayload {
+    /**
+     * Note discovery tag.
+     */
+    readonly tag: Fr;
+    /**
+     * Address of a contract that emitted the log.
+     */
+    readonly contractAddress: AztecAddress;
+    /**
+     * Decrypted incoming body.
+     */
+    readonly incomingBodyPlaintext: Buffer;
+    constructor(
+    /**
+     * Note discovery tag.
+     */
+    tag: Fr, 
+    /**
+     * Address of a contract that emitted the log.
+     */
+    contractAddress: AztecAddress, 
+    /**
+     * Decrypted incoming body.
+     */
+    incomingBodyPlaintext: Buffer);
+    generatePayload(ephSk: GrumpkinScalar, recipient: AztecAddress, rand?: (len: number) => Buffer): Promise<PrivateLog>;
+    /**
+     * 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 decryptAsIncoming(payload: Fr[], addressSecret: GrumpkinScalar): Promise<EncryptedLogPayload | undefined>;
+    private static isAcceptableError;
+    toBuffer(): Buffer;
+}
+//# sourceMappingURL=encrypted_log_payload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encrypted_log_payload.d.ts","sourceRoot":"","sources":["../../../src/logs/l1_payload/encrypted_log_payload.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,EAAE,EAAE,KAAK,cAAc,EAA0B,MAAM,0BAA0B,CAAC;AAG3F,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAuC/C;;GAEG;AACH,qBAAa,mBAAmB;IAE5B;;OAEG;aACa,GAAG,EAAE,EAAE;IACvB;;OAEG;aACa,eAAe,EAAE,YAAY;IAC7C;;OAEG;aACa,qBAAqB,EAAE,MAAM;;IAX7C;;OAEG;IACa,GAAG,EAAE,EAAE;IACvB;;OAEG;IACa,eAAe,EAAE,YAAY;IAC7C;;OAEG;IACa,qBAAqB,EAAE,MAAM;IAKlC,eAAe,CAC1B,KAAK,EAAE,cAAc,EACrB,SAAS,EAAE,YAAY,EACvB,IAAI,GAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAoB,GAC1C,OAAO,CAAC,UAAU,CAAC;IAsDtB;;;;;;;;;OASG;WACiB,iBAAiB,CACnC,OAAO,EAAE,EAAE,EAAE,EACb,aAAa,EAAE,cAAc,GAC5B,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IAiD3C,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAWzB,QAAQ;CAGhB"}

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';