@aztec/key-store 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/dest/account_privacy_keys.d.ts

@@ -0,0 +1,23 @@
+import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import type { PublicKey } from '@aztec/stdlib/keys';
+/**
+ * The four master privacy secret keys the key store holds for an account: the nullifier-hiding, incoming-viewing,
+ * outgoing-viewing, and tagging keys.
+ */
+export type AccountPrivacySecretKeys = {
+    masterNullifierHidingSecretKey: GrumpkinScalar;
+    masterIncomingViewingSecretKey: GrumpkinScalar;
+    masterOutgoingViewingSecretKey: GrumpkinScalar;
+    masterTaggingSecretKey: GrumpkinScalar;
+};
+/**
+ * The keys needed to register an account: the four privacy secret keys the key store holds, plus the *public*
+ * message-signing and fallback keys. The message-signing and fallback secret keys are withheld from the key store (and
+ * hence from PXE, which embeds it), since it is not trusted to hold them: only their public keys are needed (to
+ * reconstruct the account's address).
+ */
+export type AccountPrivacyKeys = AccountPrivacySecretKeys & {
+    masterMessageSigningPublicKey: PublicKey;
+    masterFallbackPublicKey: PublicKey;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9wcml2YWN5X2tleXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9hY2NvdW50X3ByaXZhY3lfa2V5cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVwRDs7O0dBR0c7QUFDSCxNQUFNLE1BQU0sd0JBQXdCLEdBQUc7SUFDckMsOEJBQThCLEVBQUUsY0FBYyxDQUFDO0lBQy9DLDhCQUE4QixFQUFFLGNBQWMsQ0FBQztJQUMvQyw4QkFBOEIsRUFBRSxjQUFjLENBQUM7SUFDL0Msc0JBQXNCLEVBQUUsY0FBYyxDQUFDO0NBQ3hDLENBQUM7QUFFRjs7Ozs7R0FLRztBQUNILE1BQU0sTUFBTSxrQkFBa0IsR0FBRyx3QkFBd0IsR0FBRztJQUMxRCw2QkFBNkIsRUFBRSxTQUFTLENBQUM7SUFDekMsdUJBQXVCLEVBQUUsU0FBUyxDQUFDO0NBQ3BDLENBQUMifQ==

package/dest/account_privacy_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account_privacy_keys.d.ts","sourceRoot":"","sources":["../src/account_privacy_keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,8BAA8B,EAAE,cAAc,CAAC;IAC/C,8BAA8B,EAAE,cAAc,CAAC;IAC/C,8BAA8B,EAAE,cAAc,CAAC;IAC/C,sBAAsB,EAAE,cAAc,CAAC;CACxC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,GAAG;IAC1D,6BAA6B,EAAE,SAAS,CAAC;IACzC,uBAAuB,EAAE,SAAS,CAAC;CACpC,CAAC"}

package/dest/account_privacy_keys.js

@@ -0,0 +1,6 @@
+/**
+ * The keys needed to register an account: the four privacy secret keys the key store holds, plus the *public*
+ * message-signing and fallback keys. The message-signing and fallback secret keys are withheld from the key store (and
+ * hence from PXE, which embeds it), since it is not trusted to hold them: only their public keys are needed (to
+ * reconstruct the account's address).
+ */ export { };

package/dest/index.d.ts

@@ -1,2 +1,3 @@
+export * from './account_privacy_keys.js';
 export * from './key_store.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsZ0JBQWdCLENBQUMifQ==

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC"}

package/dest/index.js

@@ -1 +1,2 @@
+export * from './account_privacy_keys.js';
 export * from './key_store.js';

package/dest/key_store.d.ts

@@ -6,6 +6,7 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { CompleteAddress, type PartialAddress } from '@aztec/stdlib/contract';
 import { KeyValidationRequest } from '@aztec/stdlib/kernel';
 import { type KeyPrefix, type PublicKey } from '@aztec/stdlib/keys';
+import type { AccountPrivacyKeys, AccountPrivacySecretKeys } from './account_privacy_keys.js';
 /**
  * Used for managing keys. Can hold keys of multiple accounts.
  */
@@ -14,22 +15,26 @@ export declare class KeyStore {
     static readonly SCHEMA_VERSION = 1;
     constructor(database: AztecAsyncKVStore);
     /**
-     * Creates a new account from a randomly generated secret key.
-     * @returns A promise that resolves to the newly created account's CompleteAddress.
-     */
-    createAccount(): Promise<CompleteAddress>;
-    /**
-     * Adds an account to the key store from the provided secret key.
-     * @param sk - The secret key of the account.
+     * Adds an account to the key store.
+     *
+     * The key store holds the four privacy secret keys (nullifier-hiding, incoming-viewing, outgoing-viewing, tagging),
+     * but only the *public* message-signing and fallback keys: their secret keys are withheld, since the key store (and
+     * PXE, which embeds it) is not trusted to hold them. The public keys are still needed to reconstruct the account's
+     * address, which commits to all six master public keys.
+     *
+     * @param keys - The account's privacy keys: four secret keys plus the message-signing and fallback public keys.
      * @param partialAddress - The partial address of the account.
      * @returns The account's complete address.
+     * @throws If any of the account's six master public keys would be the point at infinity.
      */
-    addAccount(sk: Fr, partialAddress: PartialAddress): Promise<CompleteAddress>;
+    addAccount(keys: AccountPrivacyKeys, partialAddress: PartialAddress): Promise<CompleteAddress>;
     /**
      * Retrieves addresses of accounts stored in the key store.
      * @returns A Promise that resolves to an array of account addresses.
      */
     getAccounts(): Promise<AztecAddress[]>;
+    /** Checks whether an account is registered in the key store. */
+    hasAccount(account: AztecAddress): Promise<boolean>;
     /**
      * Gets the key validation request for a given master public key hash and contract address.
      * @throws If the account corresponding to the master public key hash does not exist in the key store.
@@ -41,38 +46,36 @@ export declare class KeyStore {
     /**
      * Gets the master nullifier public key for a given account.
      * @throws If the account does not exist in the key store.
-     * @param account - The account address for which to retrieve the master nullifier public key.
-     * @returns The master nullifier public key for the account.
      */
-    getMasterNullifierPublicKey(account: AztecAddress): Promise<PublicKey>;
+    getMasterNullifierHidingPublicKey(account: AztecAddress): Promise<PublicKey>;
     /**
      * Gets the master incoming viewing public key for a given account.
      * @throws If the account does not exist in the key store.
-     * @param account - The account address for which to retrieve the master incoming viewing public key.
-     * @returns The master incoming viewing public key for the account.
      */
     getMasterIncomingViewingPublicKey(account: AztecAddress): Promise<PublicKey>;
     /**
      * Retrieves the master outgoing viewing public key.
      * @throws If the account does not exist in the key store.
-     * @param account - The account to retrieve the master outgoing viewing key for.
-     * @returns A Promise that resolves to the master outgoing viewing key.
      */
     getMasterOutgoingViewingPublicKey(account: AztecAddress): Promise<PublicKey>;
     /**
      * Retrieves the master tagging public key.
      * @throws If the account does not exist in the key store.
-     * @param account - The account to retrieve the master tagging key for.
-     * @returns A Promise that resolves to the master tagging key.
      */
     getMasterTaggingPublicKey(account: AztecAddress): Promise<PublicKey>;
     /**
      * Retrieves master incoming viewing secret key.
      * @throws If the account does not exist in the key store.
-     * @param account - The account to retrieve the master incoming viewing secret key for.
-     * @returns A Promise that resolves to the master incoming viewing secret key.
      */
     getMasterIncomingViewingSecretKey(account: AztecAddress): Promise<GrumpkinScalar>;
+    /**
+     * Retrieves the four privacy secret keys the key store holds for an account. Paired with {@link addAccount}, this
+     * allows exporting an account's privacy secret keys, e.g. to re-register it on another PXE. The message-signing and
+     * fallback secret keys are not held by the key store and so are not returned.
+     *
+     * @throws If the account does not exist in the key store.
+     */
+    getAccountSecretKeys(account: AztecAddress): Promise<AccountPrivacySecretKeys>;
     /**
      * Retrieves application outgoing viewing secret key.
      * @throws If the account does not exist in the key store.
@@ -82,13 +85,20 @@ export declare class KeyStore {
      */
     getAppOutgoingViewingSecretKey(account: AztecAddress, app: AztecAddress): Promise<Fr>;
     /**
-     * Retrieves the sk_m corresponding to the pk_m.
-     * @throws If the provided public key is not associated with any of the registered accounts.
-     * @param pkM - The master public key to get secret key for.
+     * Retrieves the sk_m corresponding to the given pk_m hash.
+     * @throws If the provided hash is not associated with any of the registered accounts.
+     * @param pkMHash - The master public key hash to get secret key for.
      * @returns A Promise that resolves to sk_m.
      * @dev Used when feeding the sk_m to the kernel circuit for keys verification.
      */
-    getMasterSecretKey(pkM: PublicKey): Promise<GrumpkinScalar>;
+    getMasterSecretKey(pkMHash: Fr): Promise<GrumpkinScalar>;
+    /**
+     * Checks whether a given account has a key matching the provided master public key hash.
+     * @param account - The account address to check.
+     * @param pkMHash - The master public key hash to look for.
+     * @returns True if the account has a key with the given hash.
+     */
+    accountHasKey(account: AztecAddress, pkMHash: Fr): Promise<boolean>;
     /**
      * Gets the key prefix and account address for a given value.
      * @returns A tuple containing the key prefix and account address.
@@ -97,4 +107,4 @@ export declare class KeyStore {
      */
     getKeyPrefixAndAccount(value: Bufferable): Promise<[KeyPrefix, AztecAddress]>;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/key_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"key_store.d.ts","sourceRoot":"","sources":["../src/key_store.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,cAAc,EAAS,MAAM,mCAAmC,CAAC;AAE1E,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,6BAA6B,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,SAAS,EAIf,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,qBAAa,QAAQ;;IACnB,gBAAuB,cAAc,KAAK;IAG1C,YAAY,QAAQ,EAAE,iBAAiB,EAEtC;IAED;;;OAGG;IACI,aAAa,IAAI,OAAO,CAAC,eAAe,CAAC,CAI/C;IAED;;;;;OAKG;IACU,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAoCxF;IAED;;;OAGG;IACU,WAAW,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAKlD;IAED;;;;;;OAMG;IACU,uBAAuB,CAAC,OAAO,EAAE,EAAE,EAAE,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAqC9G;IAED;;;;;OAKG;IACU,2BAA2B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAQlF;IAED;;;;;OAKG;IACU,iCAAiC,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAQxF;IAED;;;;;OAKG;IACU,iCAAiC,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAQxF;IAED;;;;;OAKG;IACU,yBAAyB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAQhF;IAED;;;;;OAKG;IACU,iCAAiC,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAQ7F;IAED;;;;;;OAMG;IACU,8BAA8B,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAajG;IAED;;;;;;OAMG;IACU,kBAAkB,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,cAAc,CAAC,CAiBvE;IAED;;;;;OAKG;IACU,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAczF;CACF"}
+{"version":3,"file":"key_store.d.ts","sourceRoot":"","sources":["../src/key_store.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,cAAc,EAAS,MAAM,mCAAmC,CAAC;AAE1E,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,6BAA6B,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,SAAS,EAKf,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AA+D9F;;GAEG;AACH,qBAAa,QAAQ;;IACnB,gBAAuB,cAAc,KAAK;IAI1C,YAAY,QAAQ,EAAE,iBAAiB,EAGtC;IAED;;;;;;;;;;;;OAYG;IACU,UAAU,CAAC,IAAI,EAAE,kBAAkB,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAG1G;IAED;;;OAGG;IACU,WAAW,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAKlD;IAED,gEAAgE;IACnD,UAAU,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAE/D;IAED;;;;;;OAMG;IACI,uBAAuB,CAAC,OAAO,EAAE,EAAE,EAAE,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA0CxG;IAED;;;OAGG;IACU,iCAAiC,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAExF;IAED;;;OAGG;IACU,iCAAiC,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAExF;IAED;;;OAGG;IACU,iCAAiC,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAExF;IAED;;;OAGG;IACU,yBAAyB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAEhF;IAED;;;OAGG;IACU,iCAAiC,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAE7F;IAED;;;;;;OAMG;IACU,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAQ1F;IAED;;;;;;OAMG;IACU,8BAA8B,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAOjG;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CA6B9D;IAED;;;;;OAKG;IACI,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAWzE;IAED;;;;;OAKG;IACU,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAczF;CAgFF"}

package/dest/key_store.js

@@ -1,68 +1,88 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 import { toArray } from '@aztec/foundation/iterable';
 import { serializeToBuffer } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { CompleteAddress } from '@aztec/stdlib/contract';
 import { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import { KEY_PREFIXES, computeAppSecretKey, deriveKeys, derivePublicKeyFromSecretKey } from '@aztec/stdlib/keys';
+import { KEY_PREFIXES, PublicKeys, computeAppSecretKey, derivePublicKeyFromSecretKey, hashPublicKey } from '@aztec/stdlib/keys';
+/** Maps a key prefix to the storage suffix for the corresponding master secret key. */ function secretKeyStorageSuffix(prefix) {
+    return prefix === 'n' ? 'nhk_m' : `${prefix}sk_m`;
+}
+/**
+ * Computes the public counterparts of an account's four privacy secret keys and assembles its {@link PublicKeys} struct
+ * (used to derive the address), from the {@link AccountPrivacyKeys} passed to {@link KeyStore.addAccount}.
+ *
+ * The message-signing and fallback keys are already supplied as public keys, since the key store never holds their
+ * secrets.
+ */ async function completeAccountKeys(keys) {
+    const { masterNullifierHidingSecretKey, masterIncomingViewingSecretKey, masterOutgoingViewingSecretKey, masterTaggingSecretKey, masterMessageSigningPublicKey, masterFallbackPublicKey } = keys;
+    const masterNullifierHidingPublicKey = await derivePublicKeyFromSecretKey(masterNullifierHidingSecretKey);
+    const masterIncomingViewingPublicKey = await derivePublicKeyFromSecretKey(masterIncomingViewingSecretKey);
+    const masterOutgoingViewingPublicKey = await derivePublicKeyFromSecretKey(masterOutgoingViewingSecretKey);
+    const masterTaggingPublicKey = await derivePublicKeyFromSecretKey(masterTaggingSecretKey);
+    for (const [name, publicKey] of Object.entries({
+        masterNullifierHidingPublicKey,
+        masterIncomingViewingPublicKey,
+        masterOutgoingViewingPublicKey,
+        masterTaggingPublicKey,
+        masterMessageSigningPublicKey,
+        masterFallbackPublicKey
+    })){
+        if (publicKey.isInfinite) {
+            throw new Error(`Cannot register an account with an infinity ${name}.`);
+        }
+    }
+    const publicKeys = new PublicKeys(await hashPublicKey(masterNullifierHidingPublicKey), masterIncomingViewingPublicKey, await hashPublicKey(masterOutgoingViewingPublicKey), await hashPublicKey(masterTaggingPublicKey), await hashPublicKey(masterMessageSigningPublicKey), await hashPublicKey(masterFallbackPublicKey));
+    return {
+        masterNullifierHidingSecretKey,
+        masterIncomingViewingSecretKey,
+        masterOutgoingViewingSecretKey,
+        masterTaggingSecretKey,
+        masterNullifierHidingPublicKey,
+        masterOutgoingViewingPublicKey,
+        masterTaggingPublicKey,
+        publicKeys
+    };
+}
 /**
  * Used for managing keys. Can hold keys of multiple accounts.
  */ export class KeyStore {
     static SCHEMA_VERSION = 1;
+    #db;
     #keys;
     constructor(database){
+        this.#db = database;
         this.#keys = database.openMap('key_store');
     }
     /**
-   * Creates a new account from a randomly generated secret key.
-   * @returns A promise that resolves to the newly created account's CompleteAddress.
-   */ createAccount() {
-        const sk = Fr.random();
-        const partialAddress = Fr.random();
-        return this.addAccount(sk, partialAddress);
-    }
-    /**
-   * Adds an account to the key store from the provided secret key.
-   * @param sk - The secret key of the account.
+   * Adds an account to the key store.
+   *
+   * The key store holds the four privacy secret keys (nullifier-hiding, incoming-viewing, outgoing-viewing, tagging),
+   * but only the *public* message-signing and fallback keys: their secret keys are withheld, since the key store (and
+   * PXE, which embeds it) is not trusted to hold them. The public keys are still needed to reconstruct the account's
+   * address, which commits to all six master public keys.
+   *
+   * @param keys - The account's privacy keys: four secret keys plus the message-signing and fallback public keys.
    * @param partialAddress - The partial address of the account.
    * @returns The account's complete address.
-   */ async addAccount(sk, partialAddress) {
-        const { masterNullifierSecretKey, masterIncomingViewingSecretKey, masterOutgoingViewingSecretKey, masterTaggingSecretKey, publicKeys } = await deriveKeys(sk);
-        const completeAddress = await CompleteAddress.fromSecretKeyAndPartialAddress(sk, partialAddress);
-        const { address: account } = completeAddress;
-        // Naming of keys is as follows ${account}-${n/iv/ov/t}${sk/pk}_m
-        await this.#keys.set(`${account.toString()}-ivsk_m`, masterIncomingViewingSecretKey.toBuffer());
-        await this.#keys.set(`${account.toString()}-ovsk_m`, masterOutgoingViewingSecretKey.toBuffer());
-        await this.#keys.set(`${account.toString()}-tsk_m`, masterTaggingSecretKey.toBuffer());
-        await this.#keys.set(`${account.toString()}-nsk_m`, masterNullifierSecretKey.toBuffer());
-        await this.#keys.set(`${account.toString()}-npk_m`, publicKeys.masterNullifierPublicKey.toBuffer());
-        await this.#keys.set(`${account.toString()}-ivpk_m`, publicKeys.masterIncomingViewingPublicKey.toBuffer());
-        await this.#keys.set(`${account.toString()}-ovpk_m`, publicKeys.masterOutgoingViewingPublicKey.toBuffer());
-        await this.#keys.set(`${account.toString()}-tpk_m`, publicKeys.masterTaggingPublicKey.toBuffer());
-        // We store pk_m_hash under `account-{n/iv/ov/t}pk_m_hash` key to be able to obtain address and key prefix
-        // using the #getKeyPrefixAndAccount function later on
-        const masterNullifierPublicKeyHash = await publicKeys.masterNullifierPublicKey.hash();
-        await this.#keys.set(`${account.toString()}-npk_m_hash`, masterNullifierPublicKeyHash.toBuffer());
-        const masterIncomingViewingPublicKeyHash = await publicKeys.masterIncomingViewingPublicKey.hash();
-        await this.#keys.set(`${account.toString()}-ivpk_m_hash`, masterIncomingViewingPublicKeyHash.toBuffer());
-        const masterOutgoingViewingPublicKeyHash = await publicKeys.masterOutgoingViewingPublicKey.hash();
-        await this.#keys.set(`${account.toString()}-ovpk_m_hash`, masterOutgoingViewingPublicKeyHash.toBuffer());
-        const masterTaggingPublicKeyHash = await publicKeys.masterTaggingPublicKey.hash();
-        await this.#keys.set(`${account.toString()}-tpk_m_hash`, masterTaggingPublicKeyHash.toBuffer());
-        // At last, we return the newly derived account address
-        return completeAddress;
+   * @throws If any of the account's six master public keys would be the point at infinity.
+   */ async addAccount(keys, partialAddress) {
+        const accountKeys = await completeAccountKeys(keys);
+        return this.#storeAccountKeys(accountKeys, partialAddress);
     }
     /**
    * Retrieves addresses of accounts stored in the key store.
    * @returns A Promise that resolves to an array of account addresses.
    */ async getAccounts() {
-        const allMapKeys = await toArray(this.#keys.keysAsync());
+        const allMapKeys = await this.#db.transactionAsync(()=>toArray(this.#keys.keysAsync()));
         // We return account addresses based on the map keys that end with '-ivsk_m'
         const accounts = allMapKeys.filter((key)=>key.endsWith('-ivsk_m')).map((key)=>key.split('-')[0]);
-        return accounts.map((account)=>AztecAddress.fromString(account));
+        return accounts.map((account)=>AztecAddress.fromStringUnsafe(account));
+    }
+    /** Checks whether an account is registered in the key store. */ async hasAccount(account) {
+        return !!await this.#db.transactionAsync(()=>this.#keys.getAsync(`${account.toString()}-ivsk_m`));
     }
     /**
    * Gets the key validation request for a given master public key hash and contract address.
@@ -70,92 +90,86 @@ import { KEY_PREFIXES, computeAppSecretKey, deriveKeys, derivePublicKeyFromSecre
    * @param pkMHash - The master public key hash.
    * @param contractAddress - The contract address to silo the secret key in the key validation request with.
    * @returns The key validation request.
-   */ async getKeyValidationRequest(pkMHash, contractAddress) {
-        const [keyPrefix, account] = await this.getKeyPrefixAndAccount(pkMHash);
-        // Now we find the master public key for the account
-        const pkMBuffer = await this.#keys.getAsync(`${account.toString()}-${keyPrefix}pk_m`);
-        if (!pkMBuffer) {
-            throw new Error(`Could not find ${keyPrefix}pk_m for account ${account.toString()} whose address was successfully obtained with ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`);
-        }
-        const pkM = Point.fromBuffer(pkMBuffer);
-        const computedPkMHash = await pkM.hash();
-        if (!computedPkMHash.equals(pkMHash)) {
-            throw new Error(`Could not find ${keyPrefix}pkM for ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`);
-        }
-        // Now we find the secret key for the public key
-        const skMBuffer = await this.#keys.getAsync(`${account.toString()}-${keyPrefix}sk_m`);
-        if (!skMBuffer) {
-            throw new Error(`Could not find ${keyPrefix}sk_m for account ${account.toString()} whose address was successfully obtained with ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`);
-        }
-        const skM = GrumpkinScalar.fromBuffer(skMBuffer);
-        // We sanity check that it's possible to derive the public key from the secret key
-        const derivedPkM = await derivePublicKeyFromSecretKey(skM);
-        if (!derivedPkM.equals(pkM)) {
-            throw new Error(`Could not derive ${keyPrefix}pkM from ${keyPrefix}skM.`);
-        }
-        // At last we silo the secret key and return the key validation request
-        const skApp = await computeAppSecretKey(skM, contractAddress, keyPrefix);
-        return new KeyValidationRequest(pkM, skApp);
+   */ getKeyValidationRequest(pkMHash, contractAddress) {
+        return this.#db.transactionAsync(async ()=>{
+            const [keyPrefix, account] = await this.getKeyPrefixAndAccount(pkMHash);
+            // Load the stored master public key point. The returned KVR carries only the hash, but we
+            // use the point here as a witness for two integrity checks below: (1) it matches the supplied
+            // hash, and (2) it matches the value derived from the stored secret key.
+            const pkMBuffer = await this.#keys.getAsync(`${account.toString()}-${keyPrefix}pk_m`);
+            if (!pkMBuffer) {
+                throw new Error(`Could not find ${keyPrefix}pk_m for account ${account.toString()} whose address was successfully obtained with ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`);
+            }
+            const pkM = Point.fromBuffer(pkMBuffer);
+            // Now we find the secret key for the public key
+            const skStorageSuffix = secretKeyStorageSuffix(keyPrefix);
+            const skMBuffer = await this.#keys.getAsync(`${account.toString()}-${skStorageSuffix}`);
+            if (!skMBuffer) {
+                throw new Error(`Could not find ${skStorageSuffix} for account ${account.toString()} whose address was successfully obtained with ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`);
+            }
+            const skM = GrumpkinScalar.fromBuffer(skMBuffer);
+            // The remaining awaits are non-DB computations. They are safe because no further IDB operations follow them.
+            const computedPkMHash = await hashPublicKey(pkM);
+            if (!computedPkMHash.equals(pkMHash)) {
+                throw new Error(`Could not find ${keyPrefix}pkM for ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`);
+            }
+            const derivedPkM = await derivePublicKeyFromSecretKey(skM);
+            if (!derivedPkM.equals(pkM)) {
+                throw new Error(`Could not derive ${keyPrefix}pkM from ${keyPrefix}skM.`);
+            }
+            const skApp = await computeAppSecretKey(skM, contractAddress, keyPrefix);
+            return new KeyValidationRequest(pkMHash, skApp);
+        });
     }
     /**
    * Gets the master nullifier public key for a given account.
    * @throws If the account does not exist in the key store.
-   * @param account - The account address for which to retrieve the master nullifier public key.
-   * @returns The master nullifier public key for the account.
-   */ async getMasterNullifierPublicKey(account) {
-        const masterNullifierPublicKeyBuffer = await this.#keys.getAsync(`${account.toString()}-npk_m`);
-        if (!masterNullifierPublicKeyBuffer) {
-            throw new Error(`Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`);
-        }
-        return Point.fromBuffer(masterNullifierPublicKeyBuffer);
+   */ async getMasterNullifierHidingPublicKey(account) {
+        return Point.fromBuffer(await this.#getMasterKeyBuffer(account, 'npk_m'));
     }
     /**
    * Gets the master incoming viewing public key for a given account.
    * @throws If the account does not exist in the key store.
-   * @param account - The account address for which to retrieve the master incoming viewing public key.
-   * @returns The master incoming viewing public key for the account.
    */ async getMasterIncomingViewingPublicKey(account) {
-        const masterIncomingViewingPublicKeyBuffer = await this.#keys.getAsync(`${account.toString()}-ivpk_m`);
-        if (!masterIncomingViewingPublicKeyBuffer) {
-            throw new Error(`Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`);
-        }
-        return Point.fromBuffer(masterIncomingViewingPublicKeyBuffer);
+        return Point.fromBuffer(await this.#getMasterKeyBuffer(account, 'ivpk_m'));
     }
     /**
    * Retrieves the master outgoing viewing public key.
    * @throws If the account does not exist in the key store.
-   * @param account - The account to retrieve the master outgoing viewing key for.
-   * @returns A Promise that resolves to the master outgoing viewing key.
    */ async getMasterOutgoingViewingPublicKey(account) {
-        const masterOutgoingViewingPublicKeyBuffer = await this.#keys.getAsync(`${account.toString()}-ovpk_m`);
-        if (!masterOutgoingViewingPublicKeyBuffer) {
-            throw new Error(`Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`);
-        }
-        return Point.fromBuffer(masterOutgoingViewingPublicKeyBuffer);
+        return Point.fromBuffer(await this.#getMasterKeyBuffer(account, 'ovpk_m'));
     }
     /**
    * Retrieves the master tagging public key.
    * @throws If the account does not exist in the key store.
-   * @param account - The account to retrieve the master tagging key for.
-   * @returns A Promise that resolves to the master tagging key.
    */ async getMasterTaggingPublicKey(account) {
-        const masterTaggingPublicKeyBuffer = await this.#keys.getAsync(`${account.toString()}-tpk_m`);
-        if (!masterTaggingPublicKeyBuffer) {
-            throw new Error(`Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`);
-        }
-        return Point.fromBuffer(masterTaggingPublicKeyBuffer);
+        return Point.fromBuffer(await this.#getMasterKeyBuffer(account, 'tpk_m'));
     }
     /**
    * Retrieves master incoming viewing secret key.
    * @throws If the account does not exist in the key store.
-   * @param account - The account to retrieve the master incoming viewing secret key for.
-   * @returns A Promise that resolves to the master incoming viewing secret key.
    */ async getMasterIncomingViewingSecretKey(account) {
-        const masterIncomingViewingSecretKeyBuffer = await this.#keys.getAsync(`${account.toString()}-ivsk_m`);
-        if (!masterIncomingViewingSecretKeyBuffer) {
-            throw new Error(`Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`);
-        }
-        return GrumpkinScalar.fromBuffer(masterIncomingViewingSecretKeyBuffer);
+        return GrumpkinScalar.fromBuffer(await this.#getMasterKeyBuffer(account, 'ivsk_m'));
+    }
+    /**
+   * Retrieves the four privacy secret keys the key store holds for an account. Paired with {@link addAccount}, this
+   * allows exporting an account's privacy secret keys, e.g. to re-register it on another PXE. The message-signing and
+   * fallback secret keys are not held by the key store and so are not returned.
+   *
+   * @throws If the account does not exist in the key store.
+   */ async getAccountSecretKeys(account) {
+        const [nhkM, ivskM, ovskM, tskM] = await this.#getMasterKeyBuffers(account, [
+            'nhk_m',
+            'ivsk_m',
+            'ovsk_m',
+            'tsk_m'
+        ]);
+        return {
+            masterNullifierHidingSecretKey: GrumpkinScalar.fromBuffer(nhkM),
+            masterIncomingViewingSecretKey: GrumpkinScalar.fromBuffer(ivskM),
+            masterOutgoingViewingSecretKey: GrumpkinScalar.fromBuffer(ovskM),
+            masterTaggingSecretKey: GrumpkinScalar.fromBuffer(tskM)
+        };
     }
     /**
    * Retrieves application outgoing viewing secret key.
@@ -164,35 +178,57 @@ import { KEY_PREFIXES, computeAppSecretKey, deriveKeys, derivePublicKeyFromSecre
    * @param app - The application address to retrieve the outgoing viewing secret key for.
    * @returns A Promise that resolves to the application outgoing viewing secret key.
    */ async getAppOutgoingViewingSecretKey(account, app) {
-        const masterOutgoingViewingSecretKeyBuffer = await this.#keys.getAsync(`${account.toString()}-ovsk_m`);
-        if (!masterOutgoingViewingSecretKeyBuffer) {
-            throw new Error(`Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`);
-        }
-        const masterOutgoingViewingSecretKey = GrumpkinScalar.fromBuffer(masterOutgoingViewingSecretKeyBuffer);
+        const masterOutgoingViewingSecretKey = GrumpkinScalar.fromBuffer(await this.#getMasterKeyBuffer(account, 'ovsk_m'));
         return poseidon2HashWithSeparator([
             masterOutgoingViewingSecretKey.hi,
             masterOutgoingViewingSecretKey.lo,
             app
-        ], GeneratorIndex.OVSK_M);
+        ], DomainSeparator.OVSK_M);
     }
     /**
-   * Retrieves the sk_m corresponding to the pk_m.
-   * @throws If the provided public key is not associated with any of the registered accounts.
-   * @param pkM - The master public key to get secret key for.
+   * Retrieves the sk_m corresponding to the given pk_m hash.
+   * @throws If the provided hash is not associated with any of the registered accounts.
+   * @param pkMHash - The master public key hash to get secret key for.
    * @returns A Promise that resolves to sk_m.
    * @dev Used when feeding the sk_m to the kernel circuit for keys verification.
-   */ async getMasterSecretKey(pkM) {
-        const [keyPrefix, account] = await this.getKeyPrefixAndAccount(pkM);
-        const secretKeyBuffer = await this.#keys.getAsync(`${account.toString()}-${keyPrefix}sk_m`);
-        if (!secretKeyBuffer) {
-            throw new Error(`Could not find ${keyPrefix}sk_m for ${keyPrefix}pk_m ${pkM.toString()}. This should not happen.`);
-        }
-        const skM = GrumpkinScalar.fromBuffer(secretKeyBuffer);
-        const derivedpkM = await derivePublicKeyFromSecretKey(skM);
-        if (!derivedpkM.equals(pkM)) {
-            throw new Error(`Could not find ${keyPrefix}skM for ${keyPrefix}pkM ${pkM.toString()} in secret keys buffer.`);
-        }
-        return Promise.resolve(skM);
+   */ getMasterSecretKey(pkMHash) {
+        return this.#db.transactionAsync(async ()=>{
+            const [keyPrefix, account] = await this.getKeyPrefixAndAccount(pkMHash);
+            const skStorageSuffix = secretKeyStorageSuffix(keyPrefix);
+            const secretKeyBuffer = await this.#keys.getAsync(`${account.toString()}-${skStorageSuffix}`);
+            if (!secretKeyBuffer) {
+                throw new Error(`Could not find ${skStorageSuffix} for ${keyPrefix}pk_m_hash ${pkMHash.toString()}. This should not happen.`);
+            }
+            const skM = GrumpkinScalar.fromBuffer(secretKeyBuffer);
+            // Non-DB computation — safe because no further IDB operations follow.
+            // Integrity check: confirm the stored secret key still derives the requested hash. The check
+            // is hash-based rather than point-equal because the on-disk identifier is `pk_m_hash`;
+            // cryptographic collision resistance of `hashPublicKey` makes this equivalent to a
+            // direct point comparison in practice.
+            const derivedPkM = await derivePublicKeyFromSecretKey(skM);
+            const derivedPkMHash = await hashPublicKey(derivedPkM);
+            if (!derivedPkMHash.equals(pkMHash)) {
+                throw new Error(`Could not find ${skStorageSuffix} for ${keyPrefix}pk_m_hash ${pkMHash.toString()} in secret keys buffer.`);
+            }
+            return skM;
+        });
+    }
+    /**
+   * Checks whether a given account has a key matching the provided master public key hash.
+   * @param account - The account address to check.
+   * @param pkMHash - The master public key hash to look for.
+   * @returns True if the account has a key with the given hash.
+   */ accountHasKey(account, pkMHash) {
+        return this.#db.transactionAsync(async ()=>{
+            const pkMHashBuffer = serializeToBuffer(pkMHash);
+            for (const prefix of KEY_PREFIXES){
+                const stored = await this.#keys.getAsync(`${account.toString()}-${prefix}pk_m_hash`);
+                if (stored && Buffer.from(stored).equals(pkMHashBuffer)) {
+                    return true;
+                }
+            }
+            return false;
+        });
     }
     /**
    * Gets the key prefix and account address for a given value.
@@ -206,7 +242,7 @@ import { KEY_PREFIXES, computeAppSecretKey, deriveKeys, derivePublicKeyFromSecre
             if (Buffer.from(val).equals(valueBuffer)) {
                 for (const prefix of KEY_PREFIXES){
                     if (key.includes(`-${prefix}`)) {
-                        const account = AztecAddress.fromString(key.split('-')[0]);
+                        const account = AztecAddress.fromStringUnsafe(key.split('-')[0]);
                         return [
                             prefix,
                             account
@@ -217,4 +253,56 @@ import { KEY_PREFIXES, computeAppSecretKey, deriveKeys, derivePublicKeyFromSecre
         }
         throw new Error(`Could not find key prefix.`);
     }
+    /**
+   * Persists a completed set of account keys and returns the resulting complete address.
+   */ async #storeAccountKeys(accountKeys, partialAddress) {
+        const { masterNullifierHidingSecretKey, masterIncomingViewingSecretKey, masterOutgoingViewingSecretKey, masterTaggingSecretKey, masterNullifierHidingPublicKey, masterOutgoingViewingPublicKey, masterTaggingPublicKey, publicKeys } = accountKeys;
+        const completeAddress = await CompleteAddress.fromPublicKeysAndPartialAddress(publicKeys, partialAddress);
+        const { address: account } = completeAddress;
+        // completeAccountKeys has already guaranteed these master public keys are non-infinity, which the kernel cannot
+        // check but the address relies on.
+        // The npk/ovpk/tpk hashes are already in publicKeys; ivpk_m_hash is computed for indexing.
+        const masterIncomingViewingPublicKeyHash = await hashPublicKey(publicKeys.ivpkM);
+        await this.#db.transactionAsync(async ()=>{
+            // Naming of keys is as follows ${account}-${n/iv/ov/t}${sk/pk}_m.
+            //
+            // The message-signing and fallback keys are not stored: their secret keys are withheld from the key store, and
+            // their public keys are only needed transiently to compute the address (they live in the AddressStore).
+            await this.#keys.set(`${account.toString()}-ivsk_m`, masterIncomingViewingSecretKey.toBuffer());
+            await this.#keys.set(`${account.toString()}-ovsk_m`, masterOutgoingViewingSecretKey.toBuffer());
+            await this.#keys.set(`${account.toString()}-tsk_m`, masterTaggingSecretKey.toBuffer());
+            await this.#keys.set(`${account.toString()}-nhk_m`, masterNullifierHidingSecretKey.toBuffer());
+            await this.#keys.set(`${account.toString()}-npk_m`, masterNullifierHidingPublicKey.toBuffer());
+            await this.#keys.set(`${account.toString()}-ivpk_m`, publicKeys.ivpkM.toBuffer());
+            await this.#keys.set(`${account.toString()}-ovpk_m`, masterOutgoingViewingPublicKey.toBuffer());
+            await this.#keys.set(`${account.toString()}-tpk_m`, masterTaggingPublicKey.toBuffer());
+            // We store pk_m_hash under `account-{n/iv/ov/t}pk_m_hash` key to be able to obtain address and key prefix
+            // using the #getKeyPrefixAndAccount function later on
+            await this.#keys.set(`${account.toString()}-npk_m_hash`, publicKeys.npkMHash.toBuffer());
+            await this.#keys.set(`${account.toString()}-ivpk_m_hash`, masterIncomingViewingPublicKeyHash.toBuffer());
+            await this.#keys.set(`${account.toString()}-ovpk_m_hash`, publicKeys.ovpkMHash.toBuffer());
+            await this.#keys.set(`${account.toString()}-tpk_m_hash`, publicKeys.tpkMHash.toBuffer());
+        });
+        return completeAddress;
+    }
+    /**
+   * Fetches a stored master key buffer for an account by its storage suffix (e.g. `npk_m`, `ivsk_m`).
+   * @throws If the account does not exist in the key store.
+   */ async #getMasterKeyBuffer(account, suffix) {
+        const [buffer] = await this.#getMasterKeyBuffers(account, [
+            suffix
+        ]);
+        return buffer;
+    }
+    /**
+   * Fetches multiple stored master key buffers for an account in a single transaction, returning them in the order of
+   * the requested storage suffixes.
+   * @throws If any of the keys is missing (i.e. the account does not exist in the key store).
+   */ async #getMasterKeyBuffers(account, suffixes) {
+        const buffers = await this.#db.transactionAsync(()=>Promise.all(suffixes.map((suffix)=>this.#keys.getAsync(`${account.toString()}-${suffix}`))));
+        if (!buffers.every((buffer)=>buffer !== undefined)) {
+            throw new Error(`Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`);
+        }
+        return buffers;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/key-store",
-  "version": "0.0.1-commit.c31f2472",
+  "version": "0.0.1-commit.c52d6e7",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -57,10 +57,10 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.c31f2472",
-    "@aztec/foundation": "0.0.1-commit.c31f2472",
-    "@aztec/kv-store": "0.0.1-commit.c31f2472",
-    "@aztec/stdlib": "0.0.1-commit.c31f2472",
+    "@aztec/constants": "0.0.1-commit.c52d6e7",
+    "@aztec/foundation": "0.0.1-commit.c52d6e7",
+    "@aztec/kv-store": "0.0.1-commit.c52d6e7",
+    "@aztec/stdlib": "0.0.1-commit.c52d6e7",
     "tslib": "^2.4.0"
   },
   "devDependencies": {

package/src/account_privacy_keys.ts

@@ -0,0 +1,24 @@
+import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import type { PublicKey } from '@aztec/stdlib/keys';
+
+/**
+ * The four master privacy secret keys the key store holds for an account: the nullifier-hiding, incoming-viewing,
+ * outgoing-viewing, and tagging keys.
+ */
+export type AccountPrivacySecretKeys = {
+  masterNullifierHidingSecretKey: GrumpkinScalar;
+  masterIncomingViewingSecretKey: GrumpkinScalar;
+  masterOutgoingViewingSecretKey: GrumpkinScalar;
+  masterTaggingSecretKey: GrumpkinScalar;
+};
+
+/**
+ * The keys needed to register an account: the four privacy secret keys the key store holds, plus the *public*
+ * message-signing and fallback keys. The message-signing and fallback secret keys are withheld from the key store (and
+ * hence from PXE, which embeds it), since it is not trusted to hold them: only their public keys are needed (to
+ * reconstruct the account's address).
+ */
+export type AccountPrivacyKeys = AccountPrivacySecretKeys & {
+  masterMessageSigningPublicKey: PublicKey;
+  masterFallbackPublicKey: PublicKey;
+};

package/src/index.ts

@@ -1 +1,2 @@
+export * from './account_privacy_keys.js';
 export * from './key_store.js';

package/src/key_store.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
@@ -12,74 +12,104 @@ import {
   KEY_PREFIXES,
   type KeyPrefix,
   type PublicKey,
+  PublicKeys,
   computeAppSecretKey,
-  deriveKeys,
   derivePublicKeyFromSecretKey,
+  hashPublicKey,
 } from '@aztec/stdlib/keys';
 
+import type { AccountPrivacyKeys, AccountPrivacySecretKeys } from './account_privacy_keys.js';
+
+/** Maps a key prefix to the storage suffix for the corresponding master secret key. */
+function secretKeyStorageSuffix(prefix: KeyPrefix): string {
+  return prefix === 'n' ? 'nhk_m' : `${prefix}sk_m`;
+}
+
+/**
+ * Computes the public counterparts of an account's four privacy secret keys and assembles its {@link PublicKeys} struct
+ * (used to derive the address), from the {@link AccountPrivacyKeys} passed to {@link KeyStore.addAccount}.
+ *
+ * The message-signing and fallback keys are already supplied as public keys, since the key store never holds their
+ * secrets.
+ */
+async function completeAccountKeys(keys: AccountPrivacyKeys) {
+  const {
+    masterNullifierHidingSecretKey,
+    masterIncomingViewingSecretKey,
+    masterOutgoingViewingSecretKey,
+    masterTaggingSecretKey,
+    masterMessageSigningPublicKey,
+    masterFallbackPublicKey,
+  } = keys;
+
+  const masterNullifierHidingPublicKey = await derivePublicKeyFromSecretKey(masterNullifierHidingSecretKey);
+  const masterIncomingViewingPublicKey = await derivePublicKeyFromSecretKey(masterIncomingViewingSecretKey);
+  const masterOutgoingViewingPublicKey = await derivePublicKeyFromSecretKey(masterOutgoingViewingSecretKey);
+  const masterTaggingPublicKey = await derivePublicKeyFromSecretKey(masterTaggingSecretKey);
+
+  for (const [name, publicKey] of Object.entries({
+    masterNullifierHidingPublicKey,
+    masterIncomingViewingPublicKey,
+    masterOutgoingViewingPublicKey,
+    masterTaggingPublicKey,
+    masterMessageSigningPublicKey,
+    masterFallbackPublicKey,
+  })) {
+    if (publicKey.isInfinite) {
+      throw new Error(`Cannot register an account with an infinity ${name}.`);
+    }
+  }
+
+  const publicKeys = new PublicKeys(
+    await hashPublicKey(masterNullifierHidingPublicKey),
+    masterIncomingViewingPublicKey,
+    await hashPublicKey(masterOutgoingViewingPublicKey),
+    await hashPublicKey(masterTaggingPublicKey),
+    await hashPublicKey(masterMessageSigningPublicKey),
+    await hashPublicKey(masterFallbackPublicKey),
+  );
+
+  return {
+    masterNullifierHidingSecretKey,
+    masterIncomingViewingSecretKey,
+    masterOutgoingViewingSecretKey,
+    masterTaggingSecretKey,
+    masterNullifierHidingPublicKey,
+    masterOutgoingViewingPublicKey,
+    masterTaggingPublicKey,
+    publicKeys,
+  };
+}
+
 /**
  * Used for managing keys. Can hold keys of multiple accounts.
  */
 export class KeyStore {
   public static readonly SCHEMA_VERSION = 1;
+  #db: AztecAsyncKVStore;
   #keys: AztecAsyncMap<string, Buffer>;
 
   constructor(database: AztecAsyncKVStore) {
+    this.#db = database;
     this.#keys = database.openMap('key_store');
   }
 
   /**
-   * Creates a new account from a randomly generated secret key.
-   * @returns A promise that resolves to the newly created account's CompleteAddress.
-   */
-  public createAccount(): Promise<CompleteAddress> {
-    const sk = Fr.random();
-    const partialAddress = Fr.random();
-    return this.addAccount(sk, partialAddress);
-  }
-
-  /**
-   * Adds an account to the key store from the provided secret key.
-   * @param sk - The secret key of the account.
+   * Adds an account to the key store.
+   *
+   * The key store holds the four privacy secret keys (nullifier-hiding, incoming-viewing, outgoing-viewing, tagging),
+   * but only the *public* message-signing and fallback keys: their secret keys are withheld, since the key store (and
+   * PXE, which embeds it) is not trusted to hold them. The public keys are still needed to reconstruct the account's
+   * address, which commits to all six master public keys.
+   *
+   * @param keys - The account's privacy keys: four secret keys plus the message-signing and fallback public keys.
    * @param partialAddress - The partial address of the account.
    * @returns The account's complete address.
+   * @throws If any of the account's six master public keys would be the point at infinity.
    */
-  public async addAccount(sk: Fr, partialAddress: PartialAddress): Promise<CompleteAddress> {
-    const {
-      masterNullifierSecretKey,
-      masterIncomingViewingSecretKey,
-      masterOutgoingViewingSecretKey,
-      masterTaggingSecretKey,
-      publicKeys,
-    } = await deriveKeys(sk);
-
-    const completeAddress = await CompleteAddress.fromSecretKeyAndPartialAddress(sk, partialAddress);
-    const { address: account } = completeAddress;
-
-    // Naming of keys is as follows ${account}-${n/iv/ov/t}${sk/pk}_m
-    await this.#keys.set(`${account.toString()}-ivsk_m`, masterIncomingViewingSecretKey.toBuffer());
-    await this.#keys.set(`${account.toString()}-ovsk_m`, masterOutgoingViewingSecretKey.toBuffer());
-    await this.#keys.set(`${account.toString()}-tsk_m`, masterTaggingSecretKey.toBuffer());
-    await this.#keys.set(`${account.toString()}-nsk_m`, masterNullifierSecretKey.toBuffer());
-
-    await this.#keys.set(`${account.toString()}-npk_m`, publicKeys.masterNullifierPublicKey.toBuffer());
-    await this.#keys.set(`${account.toString()}-ivpk_m`, publicKeys.masterIncomingViewingPublicKey.toBuffer());
-    await this.#keys.set(`${account.toString()}-ovpk_m`, publicKeys.masterOutgoingViewingPublicKey.toBuffer());
-    await this.#keys.set(`${account.toString()}-tpk_m`, publicKeys.masterTaggingPublicKey.toBuffer());
-
-    // We store pk_m_hash under `account-{n/iv/ov/t}pk_m_hash` key to be able to obtain address and key prefix
-    // using the #getKeyPrefixAndAccount function later on
-    const masterNullifierPublicKeyHash = await publicKeys.masterNullifierPublicKey.hash();
-    await this.#keys.set(`${account.toString()}-npk_m_hash`, masterNullifierPublicKeyHash.toBuffer());
-    const masterIncomingViewingPublicKeyHash = await publicKeys.masterIncomingViewingPublicKey.hash();
-    await this.#keys.set(`${account.toString()}-ivpk_m_hash`, masterIncomingViewingPublicKeyHash.toBuffer());
-    const masterOutgoingViewingPublicKeyHash = await publicKeys.masterOutgoingViewingPublicKey.hash();
-    await this.#keys.set(`${account.toString()}-ovpk_m_hash`, masterOutgoingViewingPublicKeyHash.toBuffer());
-    const masterTaggingPublicKeyHash = await publicKeys.masterTaggingPublicKey.hash();
-    await this.#keys.set(`${account.toString()}-tpk_m_hash`, masterTaggingPublicKeyHash.toBuffer());
-
-    // At last, we return the newly derived account address
-    return completeAddress;
+  public async addAccount(keys: AccountPrivacyKeys, partialAddress: PartialAddress): Promise<CompleteAddress> {
+    const accountKeys = await completeAccountKeys(keys);
+    return this.#storeAccountKeys(accountKeys, partialAddress);
   }
 
   /**
@@ -87,10 +117,15 @@ export class KeyStore {
    * @returns A Promise that resolves to an array of account addresses.
    */
   public async getAccounts(): Promise<AztecAddress[]> {
-    const allMapKeys = await toArray(this.#keys.keysAsync());
+    const allMapKeys = await this.#db.transactionAsync(() => toArray(this.#keys.keysAsync()));
     // We return account addresses based on the map keys that end with '-ivsk_m'
     const accounts = allMapKeys.filter(key => key.endsWith('-ivsk_m')).map(key => key.split('-')[0]);
-    return accounts.map(account => AztecAddress.fromString(account));
+    return accounts.map(account => AztecAddress.fromStringUnsafe(account));
+  }
+
+  /** Checks whether an account is registered in the key store. */
+  public async hasAccount(account: AztecAddress): Promise<boolean> {
+    return !!(await this.#db.transactionAsync(() => this.#keys.getAsync(`${account.toString()}-ivsk_m`)));
   }
 
   /**
@@ -100,123 +135,105 @@ export class KeyStore {
    * @param contractAddress - The contract address to silo the secret key in the key validation request with.
    * @returns The key validation request.
    */
-  public async getKeyValidationRequest(pkMHash: Fr, contractAddress: AztecAddress): Promise<KeyValidationRequest> {
-    const [keyPrefix, account] = await this.getKeyPrefixAndAccount(pkMHash);
+  public getKeyValidationRequest(pkMHash: Fr, contractAddress: AztecAddress): Promise<KeyValidationRequest> {
+    return this.#db.transactionAsync(async () => {
+      const [keyPrefix, account] = await this.getKeyPrefixAndAccount(pkMHash);
 
-    // Now we find the master public key for the account
-    const pkMBuffer = await this.#keys.getAsync(`${account.toString()}-${keyPrefix}pk_m`);
-    if (!pkMBuffer) {
-      throw new Error(
-        `Could not find ${keyPrefix}pk_m for account ${account.toString()} whose address was successfully obtained with ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`,
-      );
-    }
+      // Load the stored master public key point. The returned KVR carries only the hash, but we
+      // use the point here as a witness for two integrity checks below: (1) it matches the supplied
+      // hash, and (2) it matches the value derived from the stored secret key.
+      const pkMBuffer = await this.#keys.getAsync(`${account.toString()}-${keyPrefix}pk_m`);
+      if (!pkMBuffer) {
+        throw new Error(
+          `Could not find ${keyPrefix}pk_m for account ${account.toString()} whose address was successfully obtained with ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`,
+        );
+      }
 
-    const pkM = Point.fromBuffer(pkMBuffer);
-    const computedPkMHash = await pkM.hash();
-    if (!computedPkMHash.equals(pkMHash)) {
-      throw new Error(`Could not find ${keyPrefix}pkM for ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`);
-    }
+      const pkM = Point.fromBuffer(pkMBuffer);
 
-    // Now we find the secret key for the public key
-    const skMBuffer = await this.#keys.getAsync(`${account.toString()}-${keyPrefix}sk_m`);
-    if (!skMBuffer) {
-      throw new Error(
-        `Could not find ${keyPrefix}sk_m for account ${account.toString()} whose address was successfully obtained with ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`,
-      );
-    }
+      // Now we find the secret key for the public key
+      const skStorageSuffix = secretKeyStorageSuffix(keyPrefix);
+      const skMBuffer = await this.#keys.getAsync(`${account.toString()}-${skStorageSuffix}`);
+      if (!skMBuffer) {
+        throw new Error(
+          `Could not find ${skStorageSuffix} for account ${account.toString()} whose address was successfully obtained with ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`,
+        );
+      }
 
-    const skM = GrumpkinScalar.fromBuffer(skMBuffer);
+      const skM = GrumpkinScalar.fromBuffer(skMBuffer);
 
-    // We sanity check that it's possible to derive the public key from the secret key
-    const derivedPkM = await derivePublicKeyFromSecretKey(skM);
-    if (!derivedPkM.equals(pkM)) {
-      throw new Error(`Could not derive ${keyPrefix}pkM from ${keyPrefix}skM.`);
-    }
+      // The remaining awaits are non-DB computations. They are safe because no further IDB operations follow them.
+      const computedPkMHash = await hashPublicKey(pkM);
+      if (!computedPkMHash.equals(pkMHash)) {
+        throw new Error(`Could not find ${keyPrefix}pkM for ${keyPrefix}pk_m_hash ${pkMHash.toString()}.`);
+      }
+
+      const derivedPkM = await derivePublicKeyFromSecretKey(skM);
+      if (!derivedPkM.equals(pkM)) {
+        throw new Error(`Could not derive ${keyPrefix}pkM from ${keyPrefix}skM.`);
+      }
 
-    // At last we silo the secret key and return the key validation request
-    const skApp = await computeAppSecretKey(skM, contractAddress, keyPrefix!);
+      const skApp = await computeAppSecretKey(skM, contractAddress, keyPrefix!);
 
-    return new KeyValidationRequest(pkM, skApp);
+      return new KeyValidationRequest(pkMHash, skApp);
+    });
   }
 
   /**
    * Gets the master nullifier public key for a given account.
    * @throws If the account does not exist in the key store.
-   * @param account - The account address for which to retrieve the master nullifier public key.
-   * @returns The master nullifier public key for the account.
    */
-  public async getMasterNullifierPublicKey(account: AztecAddress): Promise<PublicKey> {
-    const masterNullifierPublicKeyBuffer = await this.#keys.getAsync(`${account.toString()}-npk_m`);
-    if (!masterNullifierPublicKeyBuffer) {
-      throw new Error(
-        `Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`,
-      );
-    }
-    return Point.fromBuffer(masterNullifierPublicKeyBuffer);
+  public async getMasterNullifierHidingPublicKey(account: AztecAddress): Promise<PublicKey> {
+    return Point.fromBuffer(await this.#getMasterKeyBuffer(account, 'npk_m'));
   }
 
   /**
    * Gets the master incoming viewing public key for a given account.
    * @throws If the account does not exist in the key store.
-   * @param account - The account address for which to retrieve the master incoming viewing public key.
-   * @returns The master incoming viewing public key for the account.
    */
   public async getMasterIncomingViewingPublicKey(account: AztecAddress): Promise<PublicKey> {
-    const masterIncomingViewingPublicKeyBuffer = await this.#keys.getAsync(`${account.toString()}-ivpk_m`);
-    if (!masterIncomingViewingPublicKeyBuffer) {
-      throw new Error(
-        `Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`,
-      );
-    }
-    return Point.fromBuffer(masterIncomingViewingPublicKeyBuffer);
+    return Point.fromBuffer(await this.#getMasterKeyBuffer(account, 'ivpk_m'));
   }
 
   /**
    * Retrieves the master outgoing viewing public key.
    * @throws If the account does not exist in the key store.
-   * @param account - The account to retrieve the master outgoing viewing key for.
-   * @returns A Promise that resolves to the master outgoing viewing key.
    */
   public async getMasterOutgoingViewingPublicKey(account: AztecAddress): Promise<PublicKey> {
-    const masterOutgoingViewingPublicKeyBuffer = await this.#keys.getAsync(`${account.toString()}-ovpk_m`);
-    if (!masterOutgoingViewingPublicKeyBuffer) {
-      throw new Error(
-        `Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`,
-      );
-    }
-    return Point.fromBuffer(masterOutgoingViewingPublicKeyBuffer);
+    return Point.fromBuffer(await this.#getMasterKeyBuffer(account, 'ovpk_m'));
   }
 
   /**
    * Retrieves the master tagging public key.
    * @throws If the account does not exist in the key store.
-   * @param account - The account to retrieve the master tagging key for.
-   * @returns A Promise that resolves to the master tagging key.
    */
   public async getMasterTaggingPublicKey(account: AztecAddress): Promise<PublicKey> {
-    const masterTaggingPublicKeyBuffer = await this.#keys.getAsync(`${account.toString()}-tpk_m`);
-    if (!masterTaggingPublicKeyBuffer) {
-      throw new Error(
-        `Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`,
-      );
-    }
-    return Point.fromBuffer(masterTaggingPublicKeyBuffer);
+    return Point.fromBuffer(await this.#getMasterKeyBuffer(account, 'tpk_m'));
   }
 
   /**
    * Retrieves master incoming viewing secret key.
    * @throws If the account does not exist in the key store.
-   * @param account - The account to retrieve the master incoming viewing secret key for.
-   * @returns A Promise that resolves to the master incoming viewing secret key.
    */
   public async getMasterIncomingViewingSecretKey(account: AztecAddress): Promise<GrumpkinScalar> {
-    const masterIncomingViewingSecretKeyBuffer = await this.#keys.getAsync(`${account.toString()}-ivsk_m`);
-    if (!masterIncomingViewingSecretKeyBuffer) {
-      throw new Error(
-        `Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`,
-      );
-    }
-    return GrumpkinScalar.fromBuffer(masterIncomingViewingSecretKeyBuffer);
+    return GrumpkinScalar.fromBuffer(await this.#getMasterKeyBuffer(account, 'ivsk_m'));
+  }
+
+  /**
+   * Retrieves the four privacy secret keys the key store holds for an account. Paired with {@link addAccount}, this
+   * allows exporting an account's privacy secret keys, e.g. to re-register it on another PXE. The message-signing and
+   * fallback secret keys are not held by the key store and so are not returned.
+   *
+   * @throws If the account does not exist in the key store.
+   */
+  public async getAccountSecretKeys(account: AztecAddress): Promise<AccountPrivacySecretKeys> {
+    const [nhkM, ivskM, ovskM, tskM] = await this.#getMasterKeyBuffers(account, ['nhk_m', 'ivsk_m', 'ovsk_m', 'tsk_m']);
+    return {
+      masterNullifierHidingSecretKey: GrumpkinScalar.fromBuffer(nhkM),
+      masterIncomingViewingSecretKey: GrumpkinScalar.fromBuffer(ivskM),
+      masterOutgoingViewingSecretKey: GrumpkinScalar.fromBuffer(ovskM),
+      masterTaggingSecretKey: GrumpkinScalar.fromBuffer(tskM),
+    };
   }
 
   /**
@@ -227,44 +244,69 @@ export class KeyStore {
    * @returns A Promise that resolves to the application outgoing viewing secret key.
    */
   public async getAppOutgoingViewingSecretKey(account: AztecAddress, app: AztecAddress): Promise<Fr> {
-    const masterOutgoingViewingSecretKeyBuffer = await this.#keys.getAsync(`${account.toString()}-ovsk_m`);
-    if (!masterOutgoingViewingSecretKeyBuffer) {
-      throw new Error(
-        `Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`,
-      );
-    }
-    const masterOutgoingViewingSecretKey = GrumpkinScalar.fromBuffer(masterOutgoingViewingSecretKeyBuffer);
+    const masterOutgoingViewingSecretKey = GrumpkinScalar.fromBuffer(await this.#getMasterKeyBuffer(account, 'ovsk_m'));
 
     return poseidon2HashWithSeparator(
       [masterOutgoingViewingSecretKey.hi, masterOutgoingViewingSecretKey.lo, app],
-      GeneratorIndex.OVSK_M,
+      DomainSeparator.OVSK_M,
     );
   }
 
   /**
-   * Retrieves the sk_m corresponding to the pk_m.
-   * @throws If the provided public key is not associated with any of the registered accounts.
-   * @param pkM - The master public key to get secret key for.
+   * Retrieves the sk_m corresponding to the given pk_m hash.
+   * @throws If the provided hash is not associated with any of the registered accounts.
+   * @param pkMHash - The master public key hash to get secret key for.
    * @returns A Promise that resolves to sk_m.
    * @dev Used when feeding the sk_m to the kernel circuit for keys verification.
    */
-  public async getMasterSecretKey(pkM: PublicKey): Promise<GrumpkinScalar> {
-    const [keyPrefix, account] = await this.getKeyPrefixAndAccount(pkM);
+  public getMasterSecretKey(pkMHash: Fr): Promise<GrumpkinScalar> {
+    return this.#db.transactionAsync(async () => {
+      const [keyPrefix, account] = await this.getKeyPrefixAndAccount(pkMHash);
 
-    const secretKeyBuffer = await this.#keys.getAsync(`${account.toString()}-${keyPrefix}sk_m`);
-    if (!secretKeyBuffer) {
-      throw new Error(
-        `Could not find ${keyPrefix}sk_m for ${keyPrefix}pk_m ${pkM.toString()}. This should not happen.`,
-      );
-    }
+      const skStorageSuffix = secretKeyStorageSuffix(keyPrefix);
+      const secretKeyBuffer = await this.#keys.getAsync(`${account.toString()}-${skStorageSuffix}`);
+      if (!secretKeyBuffer) {
+        throw new Error(
+          `Could not find ${skStorageSuffix} for ${keyPrefix}pk_m_hash ${pkMHash.toString()}. This should not happen.`,
+        );
+      }
 
-    const skM = GrumpkinScalar.fromBuffer(secretKeyBuffer);
-    const derivedpkM = await derivePublicKeyFromSecretKey(skM);
-    if (!derivedpkM.equals(pkM)) {
-      throw new Error(`Could not find ${keyPrefix}skM for ${keyPrefix}pkM ${pkM.toString()} in secret keys buffer.`);
-    }
+      const skM = GrumpkinScalar.fromBuffer(secretKeyBuffer);
+
+      // Non-DB computation — safe because no further IDB operations follow.
+      // Integrity check: confirm the stored secret key still derives the requested hash. The check
+      // is hash-based rather than point-equal because the on-disk identifier is `pk_m_hash`;
+      // cryptographic collision resistance of `hashPublicKey` makes this equivalent to a
+      // direct point comparison in practice.
+      const derivedPkM = await derivePublicKeyFromSecretKey(skM);
+      const derivedPkMHash = await hashPublicKey(derivedPkM);
+      if (!derivedPkMHash.equals(pkMHash)) {
+        throw new Error(
+          `Could not find ${skStorageSuffix} for ${keyPrefix}pk_m_hash ${pkMHash.toString()} in secret keys buffer.`,
+        );
+      }
 
-    return Promise.resolve(skM);
+      return skM;
+    });
+  }
+
+  /**
+   * Checks whether a given account has a key matching the provided master public key hash.
+   * @param account - The account address to check.
+   * @param pkMHash - The master public key hash to look for.
+   * @returns True if the account has a key with the given hash.
+   */
+  public accountHasKey(account: AztecAddress, pkMHash: Fr): Promise<boolean> {
+    return this.#db.transactionAsync(async () => {
+      const pkMHashBuffer = serializeToBuffer(pkMHash);
+      for (const prefix of KEY_PREFIXES) {
+        const stored = await this.#keys.getAsync(`${account.toString()}-${prefix}pk_m_hash`);
+        if (stored && Buffer.from(stored).equals(pkMHashBuffer)) {
+          return true;
+        }
+      }
+      return false;
+    });
   }
 
   /**
@@ -280,7 +322,7 @@ export class KeyStore {
       if (Buffer.from(val).equals(valueBuffer)) {
         for (const prefix of KEY_PREFIXES) {
           if (key.includes(`-${prefix}`)) {
-            const account = AztecAddress.fromString(key.split('-')[0]);
+            const account = AztecAddress.fromStringUnsafe(key.split('-')[0]);
             return [prefix, account];
           }
         }
@@ -288,4 +330,83 @@ export class KeyStore {
     }
     throw new Error(`Could not find key prefix.`);
   }
+
+  /**
+   * Persists a completed set of account keys and returns the resulting complete address.
+   */
+  async #storeAccountKeys(
+    accountKeys: Awaited<ReturnType<typeof completeAccountKeys>>,
+    partialAddress: PartialAddress,
+  ): Promise<CompleteAddress> {
+    const {
+      masterNullifierHidingSecretKey,
+      masterIncomingViewingSecretKey,
+      masterOutgoingViewingSecretKey,
+      masterTaggingSecretKey,
+      masterNullifierHidingPublicKey,
+      masterOutgoingViewingPublicKey,
+      masterTaggingPublicKey,
+      publicKeys,
+    } = accountKeys;
+
+    const completeAddress = await CompleteAddress.fromPublicKeysAndPartialAddress(publicKeys, partialAddress);
+    const { address: account } = completeAddress;
+
+    // completeAccountKeys has already guaranteed these master public keys are non-infinity, which the kernel cannot
+    // check but the address relies on.
+
+    // The npk/ovpk/tpk hashes are already in publicKeys; ivpk_m_hash is computed for indexing.
+    const masterIncomingViewingPublicKeyHash = await hashPublicKey(publicKeys.ivpkM);
+
+    await this.#db.transactionAsync(async () => {
+      // Naming of keys is as follows ${account}-${n/iv/ov/t}${sk/pk}_m.
+      //
+      // The message-signing and fallback keys are not stored: their secret keys are withheld from the key store, and
+      // their public keys are only needed transiently to compute the address (they live in the AddressStore).
+      await this.#keys.set(`${account.toString()}-ivsk_m`, masterIncomingViewingSecretKey.toBuffer());
+      await this.#keys.set(`${account.toString()}-ovsk_m`, masterOutgoingViewingSecretKey.toBuffer());
+      await this.#keys.set(`${account.toString()}-tsk_m`, masterTaggingSecretKey.toBuffer());
+      await this.#keys.set(`${account.toString()}-nhk_m`, masterNullifierHidingSecretKey.toBuffer());
+
+      await this.#keys.set(`${account.toString()}-npk_m`, masterNullifierHidingPublicKey.toBuffer());
+      await this.#keys.set(`${account.toString()}-ivpk_m`, publicKeys.ivpkM.toBuffer());
+      await this.#keys.set(`${account.toString()}-ovpk_m`, masterOutgoingViewingPublicKey.toBuffer());
+      await this.#keys.set(`${account.toString()}-tpk_m`, masterTaggingPublicKey.toBuffer());
+
+      // We store pk_m_hash under `account-{n/iv/ov/t}pk_m_hash` key to be able to obtain address and key prefix
+      // using the #getKeyPrefixAndAccount function later on
+      await this.#keys.set(`${account.toString()}-npk_m_hash`, publicKeys.npkMHash.toBuffer());
+      await this.#keys.set(`${account.toString()}-ivpk_m_hash`, masterIncomingViewingPublicKeyHash.toBuffer());
+      await this.#keys.set(`${account.toString()}-ovpk_m_hash`, publicKeys.ovpkMHash.toBuffer());
+      await this.#keys.set(`${account.toString()}-tpk_m_hash`, publicKeys.tpkMHash.toBuffer());
+    });
+
+    return completeAddress;
+  }
+
+  /**
+   * Fetches a stored master key buffer for an account by its storage suffix (e.g. `npk_m`, `ivsk_m`).
+   * @throws If the account does not exist in the key store.
+   */
+  async #getMasterKeyBuffer(account: AztecAddress, suffix: string): Promise<Buffer> {
+    const [buffer] = await this.#getMasterKeyBuffers(account, [suffix]);
+    return buffer;
+  }
+
+  /**
+   * Fetches multiple stored master key buffers for an account in a single transaction, returning them in the order of
+   * the requested storage suffixes.
+   * @throws If any of the keys is missing (i.e. the account does not exist in the key store).
+   */
+  async #getMasterKeyBuffers(account: AztecAddress, suffixes: string[]): Promise<Buffer[]> {
+    const buffers = await this.#db.transactionAsync(() =>
+      Promise.all(suffixes.map(suffix => this.#keys.getAsync(`${account.toString()}-${suffix}`))),
+    );
+    if (!buffers.every((buffer): buffer is Buffer => buffer !== undefined)) {
+      throw new Error(
+        `Account ${account.toString()} does not exist. Registered accounts: ${await this.getAccounts()}.`,
+      );
+    }
+    return buffers;
+  }
 }