@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/keys/public_keys.d.ts

@@ -0,0 +1,96 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { z } from 'zod';
+import { PublicKey } from './public_key.js';
+/**
+ * A non-owner's view of an account's master public keys.
+ *
+ * Only `ivpkM` is exposed as a point (since address derivation needs the curve
+ * point in-circuit); the other five keys are exposed as their `hashPublicKey` digests.
+ */
+export declare class PublicKeys {
+    /** Hash of the master nullifier public key */
+    npkMHash: Fr;
+    /** Master incoming viewing public key */
+    ivpkM: PublicKey;
+    /** Hash of the master outgoing viewing public key */
+    ovpkMHash: Fr;
+    /** Hash of the master tagging public key */
+    tpkMHash: Fr;
+    /** Hash of the master message-signing public key */
+    mspkMHash: Fr;
+    /** Hash of the master fallback public key */
+    fbpkMHash: Fr;
+    constructor(
+    /** Hash of the master nullifier public key */
+    npkMHash: Fr, 
+    /** Master incoming viewing public key */
+    ivpkM: PublicKey, 
+    /** Hash of the master outgoing viewing public key */
+    ovpkMHash: Fr, 
+    /** Hash of the master tagging public key */
+    tpkMHash: Fr, 
+    /** Hash of the master message-signing public key */
+    mspkMHash: Fr, 
+    /** Hash of the master fallback public key */
+    fbpkMHash: Fr);
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        npkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        ivpkM: z.ZodType<import("@aztec-labs/foundation/schemas").Point, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Point, string>>;
+        ovpkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        tpkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        mspkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        fbpkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    }, z.core.$strip>, z.ZodTransform<PublicKeys, {
+        npkMHash: Fr;
+        ivpkM: import("@aztec-labs/foundation/schemas").Point;
+        ovpkMHash: Fr;
+        tpkMHash: Fr;
+        mspkMHash: Fr;
+        fbpkMHash: Fr;
+    }>>;
+    static from(fields: FieldsOf<PublicKeys>): PublicKeys;
+    /**
+     * Creates a PublicKeys from a plain object without Zod validation.
+     * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
+     */
+    static fromPlainObject(obj: any): PublicKeys;
+    hash(): Promise<Fr>;
+    isEmpty(): boolean;
+    static default(): PublicKeys;
+    static random(): Promise<PublicKeys>;
+    equals(other: PublicKeys): boolean;
+    /**
+     * Converts the PublicKeys instance into a Buffer.
+     * This method should be used when encoding the address for storage, transmission or serialization purposes.
+     *
+     * @returns A Buffer representation of the PublicKeys instance.
+     */
+    toBuffer(): Buffer;
+    static fromBuffer(buffer: Buffer | BufferReader): PublicKeys;
+    toNoirStruct(): {
+        npk_m_hash: Fr;
+        ivpk_m: {
+            inner: {
+                x: Fr;
+                y: Fr;
+            };
+        };
+        ovpk_m_hash: Fr;
+        tpk_m_hash: Fr;
+        mspk_m_hash: Fr;
+        fbpk_m_hash: Fr;
+    };
+    /**
+     * Wire-format fields matching Noir's struct flattening of `PublicKeys`:
+     * `[npk_m_hash, ivpk_m.x, ivpk_m.y, ovpk_m_hash, tpk_m_hash, mspk_m_hash, fbpk_m_hash]`
+     * (7 fields).
+     */
+    toFields(): Fr[];
+    encodeToNoir(): Fr[];
+    static fromFields(fields: Fr[] | FieldReader): PublicKeys;
+    toString(): `0x${string}`;
+    static fromString(keys: string): PublicKeys;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2tleXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9rZXlzL3B1YmxpY19rZXlzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVdBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUV6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBcUIsTUFBTSxrQ0FBa0MsQ0FBQztBQUVoRyxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUM3RCxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLE9BQU8sRUFBRSxTQUFTLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFFM0Q7Ozs7O0dBS0c7QUFDSCxxQkFBYSxVQUFVO0lBRW5CLDhDQUE4QztJQUN2QyxRQUFRLEVBQUUsRUFBRTtJQUNuQix5Q0FBeUM7SUFDbEMsS0FBSyxFQUFFLFNBQVM7SUFDdkIscURBQXFEO0lBQzlDLFNBQVMsRUFBRSxFQUFFO0lBQ3BCLDRDQUE0QztJQUNyQyxRQUFRLEVBQUUsRUFBRTtJQUNuQixvREFBb0Q7SUFDN0MsU0FBUyxFQUFFLEVBQUU7SUFDcEIsNkNBQTZDO0lBQ3RDLFNBQVMsRUFBRSxFQUFFO0lBWnRCO0lBQ0UsOENBQThDO0lBQ3ZDLFFBQVEsRUFBRSxFQUFFO0lBQ25CLHlDQUF5QztJQUNsQyxLQUFLLEVBQUUsU0FBUztJQUN2QixxREFBcUQ7SUFDOUMsU0FBUyxFQUFFLEVBQUU7SUFDcEIsNENBQTRDO0lBQ3JDLFFBQVEsRUFBRSxFQUFFO0lBQ25CLG9EQUFvRDtJQUM3QyxTQUFTLEVBQUUsRUFBRTtJQUNwQiw2Q0FBNkM7SUFDdEMsU0FBUyxFQUFFLEVBQUUsRUFDbEI7SUFFSixNQUFNLEtBQUssTUFBTTs7Ozs7Ozs7Ozs7Ozs7UUFXaEI7SUFFRCxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsVUFBVSxDQUFDLGNBU3ZDO0lBRUQ7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLGVBQWUsQ0FBQyxHQUFHLEVBQUUsR0FBRyxHQUFHLFVBQVUsQ0FZM0M7SUFFSyxJQUFJLGdCQVlUO0lBRUQsT0FBTyxZQVNOO0lBRUQsTUFBTSxDQUFDLE9BQU8sSUFBSSxVQUFVLENBYzNCO0lBRUQsT0FBYSxNQUFNLElBQUksT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQWN6QztJQUVELE1BQU0sQ0FBQyxLQUFLLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FTakM7SUFFRDs7Ozs7T0FLRztJQUNILFFBQVEsSUFBSSxNQUFNLENBU2pCO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxVQUFVLENBUzNEO0lBRUQsWUFBWTs7Ozs7Ozs7Ozs7O01BWVg7SUFFRDs7OztPQUlHO0lBQ0gsUUFBUSxJQUFJLEVBQUUsRUFBRSxDQUVmO0lBR0QsWUFBWSxJQUFJLEVBQUUsRUFBRSxDQUVuQjtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxHQUFHLFdBQVcsR0FBRyxVQUFVLENBU3hEO0lBRUQsUUFBUSxrQkFFUDtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsSUFBSSxFQUFFLE1BQU0sY0FFN0I7Q0FDRiJ9

package/dest/keys/public_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_keys.d.ts","sourceRoot":"","sources":["../../src/keys/public_keys.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,kCAAkC,CAAC;AAEhG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,SAAS,EAAiB,MAAM,iBAAiB,CAAC;AAE3D;;;;;GAKG;AACH,qBAAa,UAAU;IAEnB,8CAA8C;IACvC,QAAQ,EAAE,EAAE;IACnB,yCAAyC;IAClC,KAAK,EAAE,SAAS;IACvB,qDAAqD;IAC9C,SAAS,EAAE,EAAE;IACpB,4CAA4C;IACrC,QAAQ,EAAE,EAAE;IACnB,oDAAoD;IAC7C,SAAS,EAAE,EAAE;IACpB,6CAA6C;IACtC,SAAS,EAAE,EAAE;IAZtB;IACE,8CAA8C;IACvC,QAAQ,EAAE,EAAE;IACnB,yCAAyC;IAClC,KAAK,EAAE,SAAS;IACvB,qDAAqD;IAC9C,SAAS,EAAE,EAAE;IACpB,4CAA4C;IACrC,QAAQ,EAAE,EAAE;IACnB,oDAAoD;IAC7C,SAAS,EAAE,EAAE;IACpB,6CAA6C;IACtC,SAAS,EAAE,EAAE,EAClB;IAEJ,MAAM,KAAK,MAAM;;;;;;;;;;;;;;QAWhB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,cASvC;IAED;;;OAGG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU,CAY3C;IAEK,IAAI,gBAYT;IAED,OAAO,YASN;IAED,MAAM,CAAC,OAAO,IAAI,UAAU,CAc3B;IAED,OAAa,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC,CAczC;IAED,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CASjC;IAED;;;;;OAKG;IACH,QAAQ,IAAI,MAAM,CASjB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU,CAS3D;IAED,YAAY;;;;;;;;;;;;MAYX;IAED;;;;OAIG;IACH,QAAQ,IAAI,EAAE,EAAE,CAEf;IAGD,YAAY,IAAI,EAAE,EAAE,CAEnB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,UAAU,CASxD;IAED,QAAQ,kBAEP;IAED,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,cAE7B;CACF"}

package/dest/keys/public_keys.js

@@ -0,0 +1,161 @@
+import { DEFAULT_FBPK_M_HASH, DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_MSPK_M_HASH, DEFAULT_NPK_M_HASH, DEFAULT_OVPK_M_HASH, DEFAULT_TPK_M_HASH, DomainSeparator } from '@aztec-labs/constants';
+import { poseidon2HashWithSeparator } from '@aztec-labs/foundation/crypto/poseidon';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, withoutHexPrefix } from '@aztec-labs/foundation/string';
+import { z } from 'zod';
+import { PublicKey, hashPublicKey } from './public_key.js';
+/**
+ * A non-owner's view of an account's master public keys.
+ *
+ * Only `ivpkM` is exposed as a point (since address derivation needs the curve
+ * point in-circuit); the other five keys are exposed as their `hashPublicKey` digests.
+ */ export class PublicKeys {
+    npkMHash;
+    ivpkM;
+    ovpkMHash;
+    tpkMHash;
+    mspkMHash;
+    fbpkMHash;
+    constructor(/** Hash of the master nullifier public key */ npkMHash, /** Master incoming viewing public key */ ivpkM, /** Hash of the master outgoing viewing public key */ ovpkMHash, /** Hash of the master tagging public key */ tpkMHash, /** Hash of the master message-signing public key */ mspkMHash, /** Hash of the master fallback public key */ fbpkMHash){
+        this.npkMHash = npkMHash;
+        this.ivpkM = ivpkM;
+        this.ovpkMHash = ovpkMHash;
+        this.tpkMHash = tpkMHash;
+        this.mspkMHash = mspkMHash;
+        this.fbpkMHash = fbpkMHash;
+    }
+    static get schema() {
+        return z.object({
+            npkMHash: schemas.Fr,
+            ivpkM: schemas.Point,
+            ovpkMHash: schemas.Fr,
+            tpkMHash: schemas.Fr,
+            mspkMHash: schemas.Fr,
+            fbpkMHash: schemas.Fr
+        }).transform(PublicKeys.from);
+    }
+    static from(fields) {
+        return new PublicKeys(fields.npkMHash, fields.ivpkM, fields.ovpkMHash, fields.tpkMHash, fields.mspkMHash, fields.fbpkMHash);
+    }
+    /**
+   * Creates a PublicKeys from a plain object without Zod validation.
+   * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
+   */ static fromPlainObject(obj) {
+        if (obj instanceof PublicKeys) {
+            return obj;
+        }
+        return new PublicKeys(Fr.fromPlainObject(obj.npkMHash), PublicKey.fromPlainObject(obj.ivpkM), Fr.fromPlainObject(obj.ovpkMHash), Fr.fromPlainObject(obj.tpkMHash), Fr.fromPlainObject(obj.mspkMHash), Fr.fromPlainObject(obj.fbpkMHash));
+    }
+    async hash() {
+        if (this.isEmpty()) {
+            return Fr.ZERO;
+        }
+        // Mirror Noir's `PublicKeys::hash`: hash the six single-key digests under
+        // DOM_SEP__PUBLIC_KEYS_HASH. `ivpk_m` must be reduced to its single-key digest first
+        // (Poseidon2 over [x, y]); passing the Point directly would omit the DOM_SEP__SINGLE_PUBLIC_KEY_HASH
+        const ivpkMHash = await hashPublicKey(this.ivpkM);
+        return poseidon2HashWithSeparator([
+            this.npkMHash,
+            ivpkMHash,
+            this.ovpkMHash,
+            this.tpkMHash,
+            this.mspkMHash,
+            this.fbpkMHash
+        ], DomainSeparator.PUBLIC_KEYS_HASH);
+    }
+    isEmpty() {
+        return this.npkMHash.isZero() && this.ivpkM.isZero() && this.ovpkMHash.isZero() && this.tpkMHash.isZero() && this.mspkMHash.isZero() && this.fbpkMHash.isZero();
+    }
+    static default() {
+        // Precomputed `hash_public_key(PublicKey { DEFAULT_*_X, DEFAULT_*_Y })` for the hash-only keys.
+        // Sourced from constants.gen.ts (originally defined in
+        // noir-protocol-circuits/crates/types/src/constants.nr); a self-test in public_keys.nr
+        // (`default_hashes_match_default_points`) catches drift between the *_HASH constants and
+        // the underlying X/Y points.
+        return new PublicKeys(new Fr(DEFAULT_NPK_M_HASH), new PublicKey(new Fr(DEFAULT_IVPK_M_X), new Fr(DEFAULT_IVPK_M_Y)), new Fr(DEFAULT_OVPK_M_HASH), new Fr(DEFAULT_TPK_M_HASH), new Fr(DEFAULT_MSPK_M_HASH), new Fr(DEFAULT_FBPK_M_HASH));
+    }
+    static async random() {
+        const npkM = await PublicKey.random();
+        const ovpkM = await PublicKey.random();
+        const tpkM = await PublicKey.random();
+        const mspkM = await PublicKey.random();
+        const fbpkM = await PublicKey.random();
+        return new PublicKeys(await hashPublicKey(npkM), await PublicKey.random(), await hashPublicKey(ovpkM), await hashPublicKey(tpkM), await hashPublicKey(mspkM), await hashPublicKey(fbpkM));
+    }
+    equals(other) {
+        return this.npkMHash.equals(other.npkMHash) && this.ivpkM.equals(other.ivpkM) && this.ovpkMHash.equals(other.ovpkMHash) && this.tpkMHash.equals(other.tpkMHash) && this.mspkMHash.equals(other.mspkMHash) && this.fbpkMHash.equals(other.fbpkMHash);
+    }
+    /**
+   * Converts the PublicKeys instance into a Buffer.
+   * This method should be used when encoding the address for storage, transmission or serialization purposes.
+   *
+   * @returns A Buffer representation of the PublicKeys instance.
+   */ toBuffer() {
+        return serializeToBuffer([
+            this.npkMHash,
+            this.ivpkM,
+            this.ovpkMHash,
+            this.tpkMHash,
+            this.mspkMHash,
+            this.fbpkMHash
+        ]);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const npkMHash = Fr.fromBuffer(reader);
+        const ivpkM = reader.readObject(PublicKey);
+        const ovpkMHash = Fr.fromBuffer(reader);
+        const tpkMHash = Fr.fromBuffer(reader);
+        const mspkMHash = Fr.fromBuffer(reader);
+        const fbpkMHash = Fr.fromBuffer(reader);
+        return new PublicKeys(npkMHash, ivpkM, ovpkMHash, tpkMHash, mspkMHash, fbpkMHash);
+    }
+    toNoirStruct() {
+        // We need to use lowercase identifiers as those are what the noir interface expects.
+        /* eslint-disable camelcase */ return {
+            npk_m_hash: this.npkMHash,
+            ivpk_m: this.ivpkM.toWrappedNoirStruct(),
+            ovpk_m_hash: this.ovpkMHash,
+            tpk_m_hash: this.tpkMHash,
+            mspk_m_hash: this.mspkMHash,
+            fbpk_m_hash: this.fbpkMHash
+        };
+    /* eslint-enable camelcase */ }
+    /**
+   * Wire-format fields matching Noir's struct flattening of `PublicKeys`:
+   * `[npk_m_hash, ivpk_m.x, ivpk_m.y, ovpk_m_hash, tpk_m_hash, mspk_m_hash, fbpk_m_hash]`
+   * (7 fields).
+   */ toFields() {
+        return [
+            this.npkMHash,
+            this.ivpkM.x,
+            this.ivpkM.y,
+            this.ovpkMHash,
+            this.tpkMHash,
+            this.mspkMHash,
+            this.fbpkMHash
+        ];
+    }
+    // Used in foundation/src/abi/encoder. Probably non-optimal but the encoder needs a refactor.
+    encodeToNoir() {
+        return this.toFields();
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        const npkMHash = reader.readField();
+        const ivpkM = reader.readObject(PublicKey);
+        const ovpkMHash = reader.readField();
+        const tpkMHash = reader.readField();
+        const mspkMHash = reader.readField();
+        const fbpkMHash = reader.readField();
+        return new PublicKeys(npkMHash, ivpkM, ovpkMHash, tpkMHash, mspkMHash, fbpkMHash);
+    }
+    toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromString(keys) {
+        return PublicKeys.fromBuffer(Buffer.from(withoutHexPrefix(keys), 'hex'));
+    }
+}

package/dest/keys/utils.d.ts

@@ -0,0 +1,3 @@
+import type { KeyGenerator, KeyPrefix } from './key_types.js';
+export declare function getKeyGenerator(prefix: KeyPrefix): KeyGenerator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9rZXlzL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUU5RCx3QkFBZ0IsZUFBZSxDQUFDLE1BQU0sRUFBRSxTQUFTLEdBQUcsWUFBWSxDQVEvRCJ9

package/dest/keys/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/keys/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE9D,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,YAAY,CAQ/D"}

package/dest/keys/utils.js

@@ -0,0 +1,10 @@
+import { DomainSeparator } from '@aztec-labs/constants';
+export function getKeyGenerator(prefix) {
+    const map = {
+        n: DomainSeparator.NHK_M,
+        iv: DomainSeparator.IVSK_M,
+        ov: DomainSeparator.OVSK_M,
+        t: DomainSeparator.TSK_M
+    };
+    return map[prefix];
+}

package/dest/kv-store/config.d.ts

@@ -0,0 +1,14 @@
+import { type L1ContractAddresses } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType } from '@aztec-labs/foundation/config';
+export type DataStoreConfig = {
+    dataDirectory?: string;
+    dataStoreMapSizeKb: number;
+} & Partial<Pick<L1ContractAddresses, 'rollupAddress'>>;
+export declare const dataConfigMappings: ConfigMappingsType<DataStoreConfig>;
+/**
+ * Returns the archiver configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The archiver configuration.
+ */
+export declare function getDataConfigFromEnv(): DataStoreConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMva3Ytc3RvcmUvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLG1CQUFtQixFQUFpQyxNQUFNLDRDQUE0QyxDQUFDO0FBQ3JILE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUE2QyxNQUFNLCtCQUErQixDQUFDO0FBRW5ILE1BQU0sTUFBTSxlQUFlLEdBQUc7SUFDNUIsYUFBYSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3ZCLGtCQUFrQixFQUFFLE1BQU0sQ0FBQztDQUM1QixHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsbUJBQW1CLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQztBQUV4RCxlQUFPLE1BQU0sa0JBQWtCLEVBQUUsa0JBQWtCLENBQUMsZUFBZSxDQVdsRSxDQUFDO0FBRUY7Ozs7R0FJRztBQUNILHdCQUFnQixvQkFBb0IsSUFBSSxlQUFlLENBRXREIn0=

package/dest/kv-store/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/kv-store/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAiC,MAAM,4CAA4C,CAAC;AACrH,OAAO,EAAE,KAAK,kBAAkB,EAA6C,MAAM,+BAA+B,CAAC;AAEnH,MAAM,MAAM,eAAe,GAAG;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,GAAG,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC,CAAC;AAExD,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,CAAC,eAAe,CAWlE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,eAAe,CAEtD"}

package/dest/kv-store/config.js

@@ -0,0 +1,21 @@
+import { pickL1ContractAddressMappings } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { getConfigFromMappings, numberConfigHelper } from '@aztec-labs/foundation/config';
+export const dataConfigMappings = {
+    dataDirectory: {
+        env: 'DATA_DIRECTORY',
+        description: 'Optional dir to store data. If omitted will store in memory.'
+    },
+    dataStoreMapSizeKb: {
+        env: 'DATA_STORE_MAP_SIZE_KB',
+        description: 'The maximum possible size of a data store DB in KB. Can be overridden by component-specific options.',
+        ...numberConfigHelper(128 * 1_024 * 1_024)
+    },
+    ...pickL1ContractAddressMappings('rollupAddress')
+};
+/**
+ * Returns the archiver configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The archiver configuration.
+ */ export function getDataConfigFromEnv() {
+    return getConfigFromMappings(dataConfigMappings);
+}

package/dest/kv-store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9rdi1zdG9yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQyJ9

package/dest/kv-store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kv-store/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dest/kv-store/index.js

@@ -0,0 +1 @@
+export * from './config.js';

package/dest/l1-contracts/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sMS1jb250cmFjdHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/l1-contracts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/l1-contracts/index.ts"],"names":[],"mappings":""}

package/dest/l1-contracts/index.js

@@ -0,0 +1 @@
+// No exports.

package/dest/logs/app_tagging_secret.d.ts

@@ -0,0 +1,69 @@
+import { type Fq, Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Point } from '@aztec-labs/foundation/curves/grumpkin';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+import type { CompleteAddress } from '../contract/complete_address.js';
+import { AppTaggingSecretKind } from './app_tagging_secret_kind.js';
+/**
+ * Application tagging secret used for log tagging.
+ *
+ * It bundles a tagging secret with the app contract address. Unconstrained secrets are derived by the simulator from
+ * `(sender, recipient, app)` via ECDH. Constrained secrets are supplied to the simulator by the caller as an
+ * app-siloed shared secret retrieved from a handshake registry.
+ */
+export declare class AppTaggingSecret {
+    readonly secret: Fr;
+    readonly app: AztecAddress;
+    readonly kind: AppTaggingSecretKind;
+    constructor(secret: Fr, app: AztecAddress, kind?: AppTaggingSecretKind);
+    /**
+     * Derives an app-siloed, recipient-directional tagging secret from a shared tagging secret point.
+     *
+     * App-silos the point via {@link appSiloEcdhSharedSecretPoint}, then directs the result to `recipient`:
+     * `h([s_app, recipient])`. The directional step stops a symmetric shared secret (ECDH against an address, or an
+     * arbitrary registered point) from colliding bidirectionally, so two parties never share a tag sequence.
+     *
+     * The point is obtained either via {@link computeSharedTaggingSecret} (an ECDH key exchange against a sender) or
+     * registered directly as a pre-shared secret.
+     *
+     * @param taggingSecretPoint - The shared tagging secret point (ECDH output, or a directly registered pre-shared secret)
+     * @param app - Contract address to silo the secret to
+     * @param recipient - Recipient of the log. Defines the "direction of the secret".
+     * @returns The secret that can be used along with an index to compute a tag to be included in a log.
+     */
+    static computeDirectional(taggingSecretPoint: Point, app: AztecAddress, recipient: AztecAddress): Promise<AppTaggingSecret>;
+    /**
+     * Derives the bare app-siloed tagging secret from a shared secret point via {@link appSiloEcdhSharedSecretPoint},
+     * under the given delivery-mode kind.
+     */
+    static computeAppSiloed(taggingSecretPoint: Point, app: AztecAddress, kind: AppTaggingSecretKind): Promise<AppTaggingSecret>;
+    /**
+     * Derives the tagging secret for `(externalAddress, recipient, app)` by performing an ECDH key exchange against
+     * `externalAddress` to obtain the shared point, then siloing and directing it via {@link computeDirectional}.
+     * Returns undefined if `externalAddress` is not a valid address.
+     */
+    static computeViaEcdh(localAddress: CompleteAddress, localIvsk: Fq, externalAddress: AztecAddress, app: AztecAddress, recipient: AztecAddress): Promise<AppTaggingSecret | undefined>;
+    toString(): string;
+    static fromString(str: string): AppTaggingSecret;
+}
+/**
+ * Parses a stored `AppTaggingSecret` string key.
+ */
+export declare function appTaggingSecretFromString(str: string): AppTaggingSecret;
+export declare const AppTaggingSecretSchema: z.ZodPipe<z.ZodObject<{
+    kind: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"unconstrained">, z.ZodLiteral<"constrained">]>>;
+    secret: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    app: import("@aztec-labs/foundation/schemas").ZodFor<AztecAddress>;
+}, z.core.$strip>, z.ZodTransform<AppTaggingSecret, {
+    kind: "constrained" | "unconstrained";
+    secret: Fr;
+    app: AztecAddress;
+}>>;
+/**
+ * Computes the shared tagging secret point between a local address (i.e. one for which the privacy keys are known) and
+ * an external one via a Diffie-Hellman key exchange.
+ *
+ * Returns undefined if `externalAddress` is an invalid address.
+ */
+export declare function computeSharedTaggingSecret(localAddress: CompleteAddress, localIvsk: Fq, externalAddress: AztecAddress): Promise<Point | undefined>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwX3RhZ2dpbmdfc2VjcmV0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbG9ncy9hcHBfdGFnZ2luZ19zZWNyZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ2xFLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRXZFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBUXBFOzs7Ozs7R0FNRztBQUNILHFCQUFhLGdCQUFnQjthQUVULE1BQU0sRUFBRSxFQUFFO2FBQ1YsR0FBRyxFQUFFLFlBQVk7YUFDakIsSUFBSSxFQUFFLG9CQUFvQjtJQUg1QyxZQUNrQixNQUFNLEVBQUUsRUFBRSxFQUNWLEdBQUcsRUFBRSxZQUFZLEVBQ2pCLElBQUksR0FBRSxvQkFBeUQsRUFDN0U7SUFFSjs7Ozs7Ozs7Ozs7Ozs7T0FjRztJQUNILE9BQWEsa0JBQWtCLENBQzdCLGtCQUFrQixFQUFFLEtBQUssRUFDekIsR0FBRyxFQUFFLFlBQVksRUFDakIsU0FBUyxFQUFFLFlBQVksR0FDdEIsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBSzNCO0lBRUQ7OztPQUdHO0lBQ0gsT0FBYSxnQkFBZ0IsQ0FDM0Isa0JBQWtCLEVBQUUsS0FBSyxFQUN6QixHQUFHLEVBQUUsWUFBWSxFQUNqQixJQUFJLEVBQUUsb0JBQW9CLEdBQ3pCLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUUzQjtJQUVEOzs7O09BSUc7SUFDSCxPQUFhLGNBQWMsQ0FDekIsWUFBWSxFQUFFLGVBQWUsRUFDN0IsU0FBUyxFQUFFLEVBQUUsRUFDYixlQUFlLEVBQUUsWUFBWSxFQUM3QixHQUFHLEVBQUUsWUFBWSxFQUNqQixTQUFTLEVBQUUsWUFBWSxHQUN0QixPQUFPLENBQUMsZ0JBQWdCLEdBQUcsU0FBUyxDQUFDLENBT3ZDO0lBRUQsUUFBUSxJQUFJLE1BQU0sQ0FFakI7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLEdBQUcsRUFBRSxNQUFNLEdBQUcsZ0JBQWdCLENBVy9DO0NBQ0Y7QUFFRDs7R0FFRztBQUNILHdCQUFnQiwwQkFBMEIsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLGdCQUFnQixDQUV4RTtBQUVELGVBQU8sTUFBTSxzQkFBc0I7Ozs7Ozs7O0dBTTZDLENBQUM7QUFhakY7Ozs7O0dBS0c7QUFDSCx3QkFBc0IsMEJBQTBCLENBQzlDLFlBQVksRUFBRSxlQUFlLEVBQzdCLFNBQVMsRUFBRSxFQUFFLEVBQ2IsZUFBZSxFQUFFLFlBQVksR0FDNUIsT0FBTyxDQUFDLEtBQUssR0FBRyxTQUFTLENBQUMsQ0FlNUIifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"app_tagging_secret.d.ts","sourceRoot":"","sources":["../../src/logs/app_tagging_secret.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAClE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAQpE;;;;;;GAMG;AACH,qBAAa,gBAAgB;aAET,MAAM,EAAE,EAAE;aACV,GAAG,EAAE,YAAY;aACjB,IAAI,EAAE,oBAAoB;IAH5C,YACkB,MAAM,EAAE,EAAE,EACV,GAAG,EAAE,YAAY,EACjB,IAAI,GAAE,oBAAyD,EAC7E;IAEJ;;;;;;;;;;;;;;OAcG;IACH,OAAa,kBAAkB,CAC7B,kBAAkB,EAAE,KAAK,EACzB,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAK3B;IAED;;;OAGG;IACH,OAAa,gBAAgB,CAC3B,kBAAkB,EAAE,KAAK,EACzB,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC,gBAAgB,CAAC,CAE3B;IAED;;;;OAIG;IACH,OAAa,cAAc,CACzB,YAAY,EAAE,eAAe,EAC7B,SAAS,EAAE,EAAE,EACb,eAAe,EAAE,YAAY,EAC7B,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAOvC;IAED,QAAQ,IAAI,MAAM,CAEjB;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAW/C;CACF;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAExE;AAED,eAAO,MAAM,sBAAsB;;;;;;;;GAM6C,CAAC;AAajF;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,eAAe,EAC7B,SAAS,EAAE,EAAE,EACb,eAAe,EAAE,YAAY,GAC5B,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAe5B"}

package/dest/logs/app_tagging_secret.js

@@ -0,0 +1,116 @@
+import { Grumpkin } from '@aztec-labs/foundation/crypto/grumpkin';
+import { poseidon2Hash } from '@aztec-labs/foundation/crypto/poseidon';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+import { computeAddressSecret, computePreaddress } from '../keys/derivation.js';
+import { AppTaggingSecretKind } from './app_tagging_secret_kind.js';
+import { appSiloEcdhSharedSecretPoint } from './shared_secret_derivation.js';
+const AppTaggingSecretKindSchema = z.union([
+    z.literal(AppTaggingSecretKind.UNCONSTRAINED),
+    z.literal(AppTaggingSecretKind.CONSTRAINED)
+]);
+/**
+ * Application tagging secret used for log tagging.
+ *
+ * It bundles a tagging secret with the app contract address. Unconstrained secrets are derived by the simulator from
+ * `(sender, recipient, app)` via ECDH. Constrained secrets are supplied to the simulator by the caller as an
+ * app-siloed shared secret retrieved from a handshake registry.
+ */ export class AppTaggingSecret {
+    secret;
+    app;
+    kind;
+    constructor(secret, app, kind = AppTaggingSecretKind.UNCONSTRAINED){
+        this.secret = secret;
+        this.app = app;
+        this.kind = kind;
+    }
+    /**
+   * Derives an app-siloed, recipient-directional tagging secret from a shared tagging secret point.
+   *
+   * App-silos the point via {@link appSiloEcdhSharedSecretPoint}, then directs the result to `recipient`:
+   * `h([s_app, recipient])`. The directional step stops a symmetric shared secret (ECDH against an address, or an
+   * arbitrary registered point) from colliding bidirectionally, so two parties never share a tag sequence.
+   *
+   * The point is obtained either via {@link computeSharedTaggingSecret} (an ECDH key exchange against a sender) or
+   * registered directly as a pre-shared secret.
+   *
+   * @param taggingSecretPoint - The shared tagging secret point (ECDH output, or a directly registered pre-shared secret)
+   * @param app - Contract address to silo the secret to
+   * @param recipient - Recipient of the log. Defines the "direction of the secret".
+   * @returns The secret that can be used along with an index to compute a tag to be included in a log.
+   */ static async computeDirectional(taggingSecretPoint, app, recipient) {
+        const appSiloedSecret = await appSiloEcdhSharedSecretPoint(taggingSecretPoint, app);
+        const directionalAppTaggingSecret = await poseidon2Hash([
+            appSiloedSecret,
+            recipient
+        ]);
+        return new AppTaggingSecret(directionalAppTaggingSecret, app);
+    }
+    /**
+   * Derives the bare app-siloed tagging secret from a shared secret point via {@link appSiloEcdhSharedSecretPoint},
+   * under the given delivery-mode kind.
+   */ static async computeAppSiloed(taggingSecretPoint, app, kind) {
+        return new AppTaggingSecret(await appSiloEcdhSharedSecretPoint(taggingSecretPoint, app), app, kind);
+    }
+    /**
+   * Derives the tagging secret for `(externalAddress, recipient, app)` by performing an ECDH key exchange against
+   * `externalAddress` to obtain the shared point, then siloing and directing it via {@link computeDirectional}.
+   * Returns undefined if `externalAddress` is not a valid address.
+   */ static async computeViaEcdh(localAddress, localIvsk, externalAddress, app, recipient) {
+        const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
+        if (!taggingSecretPoint) {
+            return undefined;
+        }
+        return AppTaggingSecret.computeDirectional(taggingSecretPoint, app, recipient);
+    }
+    toString() {
+        return `${this.kind}:${this.secret.toString()}:${this.app.toString()}`;
+    }
+    static fromString(str) {
+        const parts = str.split(':');
+        if (parts.length !== 3) {
+            throw new Error(`Invalid AppTaggingSecret string: ${str}`);
+        }
+        const [kindStr, secretStr, appStr] = parts;
+        return new AppTaggingSecret(Fr.fromString(secretStr), AztecAddress.fromStringUnsafe(appStr), appTaggingSecretKindFromString(kindStr));
+    }
+}
+/**
+ * Parses a stored `AppTaggingSecret` string key.
+ */ export function appTaggingSecretFromString(str) {
+    return AppTaggingSecret.fromString(str);
+}
+export const AppTaggingSecretSchema = z.object({
+    kind: AppTaggingSecretKindSchema.default(AppTaggingSecretKind.UNCONSTRAINED),
+    secret: Fr.schema,
+    app: AztecAddress.schema
+}).transform(({ kind, secret, app })=>new AppTaggingSecret(secret, app, kind));
+function appTaggingSecretKindFromString(kind) {
+    switch(kind){
+        case AppTaggingSecretKind.CONSTRAINED:
+            return AppTaggingSecretKind.CONSTRAINED;
+        case AppTaggingSecretKind.UNCONSTRAINED:
+            return AppTaggingSecretKind.UNCONSTRAINED;
+        default:
+            throw new Error(`Invalid AppTaggingSecret kind: ${kind}`);
+    }
+}
+/**
+ * Computes the shared tagging secret point between a local address (i.e. one for which the privacy keys are known) and
+ * an external one via a Diffie-Hellman key exchange.
+ *
+ * Returns undefined if `externalAddress` is an invalid address.
+ */ export async function computeSharedTaggingSecret(localAddress, localIvsk, externalAddress) {
+    // An invalid address has no corresponding address point
+    if (!await externalAddress.isValid()) {
+        return undefined;
+    }
+    const externalAddressPoint = await externalAddress.toAddressPoint();
+    const localPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
+    const localAddressSecret = await computeAddressSecret(localPreaddress, localIvsk);
+    // For a given local address A and external address B, the shared tagging secret S is (h_A + ivsk_A) * Addr_Point_B
+    // (conceptually, in reality we don't use h_A + ivsk_A directly but rather the actual address secret, which is the
+    // same but with an optional sign adjustment to prevent A's address point from having a negative y-coordinate).
+    return Grumpkin.mul(externalAddressPoint, localAddressSecret);
+}

package/dest/logs/app_tagging_secret_kind.d.ts

@@ -0,0 +1,7 @@
+export declare const AppTaggingSecretKind: {
+    readonly UNCONSTRAINED: "unconstrained";
+    readonly CONSTRAINED: "constrained";
+};
+export type AppTaggingSecretKind = (typeof AppTaggingSecretKind)[keyof typeof AppTaggingSecretKind];
+export declare function appTaggingSecretKindFromDeliveryMode(deliveryMode: number): AppTaggingSecretKind;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwX3RhZ2dpbmdfc2VjcmV0X2tpbmQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sb2dzL2FwcF90YWdnaW5nX3NlY3JldF9raW5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQU8sTUFBTSxvQkFBb0I7OztDQUd2QixDQUFDO0FBRVgsTUFBTSxNQUFNLG9CQUFvQixHQUFHLENBQUMsT0FBTyxvQkFBb0IsQ0FBQyxDQUFDLE1BQU0sT0FBTyxvQkFBb0IsQ0FBQyxDQUFDO0FBTXBHLHdCQUFnQixvQ0FBb0MsQ0FBQyxZQUFZLEVBQUUsTUFBTSxHQUFHLG9CQUFvQixDQVMvRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"app_tagging_secret_kind.d.ts","sourceRoot":"","sources":["../../src/logs/app_tagging_secret_kind.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB;;;CAGvB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAMpG,wBAAgB,oCAAoC,CAAC,YAAY,EAAE,MAAM,GAAG,oBAAoB,CAS/F"}

package/dest/logs/app_tagging_secret_kind.js

@@ -0,0 +1,17 @@
+export const AppTaggingSecretKind = {
+    UNCONSTRAINED: 'unconstrained',
+    CONSTRAINED: 'constrained'
+};
+// Keep in sync with aztec::messages::delivery::OnchainDeliveryMode.
+const ONCHAIN_UNCONSTRAINED_DELIVERY_MODE = 2;
+const ONCHAIN_CONSTRAINED_DELIVERY_MODE = 3;
+export function appTaggingSecretKindFromDeliveryMode(deliveryMode) {
+    switch(deliveryMode){
+        case ONCHAIN_UNCONSTRAINED_DELIVERY_MODE:
+            return AppTaggingSecretKind.UNCONSTRAINED;
+        case ONCHAIN_CONSTRAINED_DELIVERY_MODE:
+            return AppTaggingSecretKind.CONSTRAINED;
+        default:
+            throw new Error(`Unrecognized delivery mode for tagging: ${deliveryMode}`);
+    }
+}