@aztec/key-store 0.23.0 → 0.26.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/key-store",
-  "version": "0.23.0",
+  "version": "0.26.1",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -30,10 +30,10 @@
     "rootDir": "./src"
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.23.0",
-    "@aztec/circuits.js": "0.23.0",
-    "@aztec/foundation": "0.23.0",
-    "@aztec/kv-store": "0.23.0",
+    "@aztec/circuit-types": "0.26.1",
+    "@aztec/circuits.js": "0.26.1",
+    "@aztec/foundation": "0.26.1",
+    "@aztec/kv-store": "0.26.1",
     "tslib": "^2.4.0"
   },
   "devDependencies": {

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './key_pair.js';
+export * from './test_key_store.js';

package/src/key_pair.ts

@@ -0,0 +1,48 @@
+import { KeyPair, PublicKey } from '@aztec/circuit-types';
+import { GrumpkinPrivateKey, GrumpkinScalar } from '@aztec/circuits.js';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+
+/**
+ * The ConstantKeyPair class is an implementation of the KeyPair interface, which allows generation and management of
+ * a constant public and private key pair. It provides methods for creating a random instance of the key pair,
+ * retrieving the public key, getting the private key. This class ensures the persistence and consistency of
+ * the generated keys, making it suitable for cryptographic operations where constant key pairs are required.
+ */
+export class ConstantKeyPair implements KeyPair {
+  /**
+   * Generate a random ConstantKeyPair instance using the .
+   * The random private key is generated using 32 random bytes, and the corresponding public key is calculated
+   * by multiplying the Grumpkin generator point with the private key. This function provides an efficient
+   * way of generating unique key pairs for cryptographic purposes.
+   *
+   * @param curve - The curve used for elliptic curve cryptography operations.
+   * @returns A randomly generated ConstantKeyPair instance.
+   */
+  public static random(curve: Grumpkin) {
+    const privateKey = GrumpkinScalar.random();
+    const publicKey = curve.mul(curve.generator(), privateKey);
+    return new ConstantKeyPair(publicKey, privateKey);
+  }
+
+  /**
+   * Creates a new instance from a private key.
+   * @param curve - The curve used for elliptic curve cryptography operations.
+   * @param signer - The signer to be used on the account.
+   * @param privateKey - The private key.
+   * @returns A new instance.
+   */
+  public static fromPrivateKey(curve: Grumpkin, privateKey: GrumpkinPrivateKey) {
+    const publicKey = curve.mul(curve.generator(), privateKey);
+    return new ConstantKeyPair(publicKey, privateKey);
+  }
+
+  constructor(private publicKey: PublicKey, private privateKey: GrumpkinPrivateKey) {}
+
+  public getPublicKey(): PublicKey {
+    return this.publicKey;
+  }
+
+  public getPrivateKey(): GrumpkinPrivateKey {
+    return this.privateKey;
+  }
+}

package/src/test_key_store.ts

@@ -0,0 +1,95 @@
+import { KeyPair, KeyStore, PublicKey } from '@aztec/circuit-types';
+import {
+  AztecAddress,
+  GrumpkinPrivateKey,
+  GrumpkinScalar,
+  Point,
+  computeNullifierSecretKey,
+  computeSiloedNullifierSecretKey,
+  derivePublicKey,
+} from '@aztec/circuits.js';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
+
+import { ConstantKeyPair } from './key_pair.js';
+
+/**
+ * TestKeyStore is an implementation of the KeyStore interface, used for managing key pairs in a testing environment.
+ * It should be utilized in testing scenarios where secure key management is not required, and ease-of-use is prioritized.
+ */
+export class TestKeyStore implements KeyStore {
+  #keys: AztecMap<string, Buffer>;
+
+  constructor(private curve: Grumpkin, database: AztecKVStore) {
+    this.#keys = database.openMap('key_store');
+  }
+
+  public async addAccount(privKey: GrumpkinPrivateKey): Promise<PublicKey> {
+    const keyPair = ConstantKeyPair.fromPrivateKey(this.curve, privKey);
+    await this.#keys.setIfNotExists(keyPair.getPublicKey().toString(), keyPair.getPrivateKey().toBuffer());
+    return keyPair.getPublicKey();
+  }
+
+  public async createAccount(): Promise<PublicKey> {
+    const keyPair = ConstantKeyPair.random(this.curve);
+    await this.#keys.set(keyPair.getPublicKey().toString(), keyPair.getPrivateKey().toBuffer());
+    return keyPair.getPublicKey();
+  }
+
+  public getAccounts(): Promise<PublicKey[]> {
+    const range = Array.from(this.#keys.keys());
+    return Promise.resolve(range.map(key => Point.fromString(key)));
+  }
+
+  public getAccountPrivateKey(pubKey: PublicKey): Promise<GrumpkinPrivateKey> {
+    const account = this.getAccount(pubKey);
+    return Promise.resolve(account.getPrivateKey());
+  }
+
+  public async getNullifierSecretKey(pubKey: PublicKey) {
+    const privateKey = await this.getAccountPrivateKey(pubKey);
+    return computeNullifierSecretKey(privateKey);
+  }
+
+  public async getNullifierSecretKeyFromPublicKey(nullifierPubKey: PublicKey) {
+    const accounts = await this.getAccounts();
+    for (let i = 0; i < accounts.length; ++i) {
+      const accountPublicKey = accounts[i];
+      const privateKey = await this.getAccountPrivateKey(accountPublicKey);
+      const secretKey = computeNullifierSecretKey(privateKey);
+      const publicKey = derivePublicKey(secretKey);
+      if (publicKey.equals(nullifierPubKey)) {
+        return secretKey;
+      }
+    }
+    throw new Error('Unknown nullifier public key.');
+  }
+
+  public async getNullifierPublicKey(pubKey: PublicKey) {
+    const secretKey = await this.getNullifierSecretKey(pubKey);
+    return derivePublicKey(secretKey);
+  }
+
+  public async getSiloedNullifierSecretKey(pubKey: PublicKey, contractAddress: AztecAddress) {
+    const secretKey = await this.getNullifierSecretKey(pubKey);
+    return computeSiloedNullifierSecretKey(secretKey, contractAddress);
+  }
+
+  /**
+   * Retrieve the KeyPair object associated with a given pub key.
+   * Searches through the 'accounts' array for a matching public key and returns the corresponding account (KeyPair).
+   * Throws an error if no matching account is found in the 'accounts'.
+   *
+   * @param pubKey - The public key of the account to retrieve.
+   * @returns The KeyPair object associated with the provided key.
+   */
+  private getAccount(pubKey: PublicKey): KeyPair {
+    const privKey = this.#keys.get(pubKey.toString());
+    if (!privKey) {
+      throw new Error(
+        'Unknown account.\nSee docs for context: https://docs.aztec.network/developers/debugging/aztecnr-errors#could-not-process-note-because-of-error-unknown-account-skipping-note',
+      );
+    }
+    return ConstantKeyPair.fromPrivateKey(this.curve, GrumpkinScalar.fromBuffer(privKey));
+  }
+}