Merge pull request #249 from 0xPolygonID/fix/create-eth-id-no-bjj

fix error thrown if createBjjCredential is false and no ethSigner provided

Author: volodymyr-basiuk

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xpolygonid/js-sdk",
-  "version": "1.17.0",
+  "version": "1.17.1",
   "description": "SDK to work with Polygon ID",
   "main": "dist/node/cjs/index.js",
   "module": "dist/node/esm/index.js",

package.json

@@ -720,7 +720,7 @@ export class IdentityWallet implements IIdentityWallet {
     let credential;
     const ethSigner = opts.ethSigner;
 
-    if (!ethSigner) {
+    if (opts.createBjjCredential && !ethSigner) {
       throw new Error(
         'Ethereum signer is required to create Ethereum identities in order to transit state'
       );
@@ -747,7 +747,7 @@ export class IdentityWallet implements IIdentityWallet {
       isStateGenesis: true
     });
 
-    if (opts.createBjjCredential) {
+    if (opts.createBjjCredential && ethSigner) {
       // Old tree state genesis state
       const oldTreeState: TreeState = {
         revocationRoot: ZERO_HASH,
@@ -1489,6 +1489,13 @@ export class IdentityWallet implements IIdentityWallet {
     );
     await this._credentialWallet.saveAll(credsWithIden3MTPProof);
 
+    await this._storage.identity.saveIdentity({
+      did: did.string(),
+      state: currentState,
+      isStatePublished: true,
+      isStateGenesis: false
+    });
+
     const credRefreshed = await this._credentialWallet.findById(credential.id);
     if (!credRefreshed) {
       throw new Error('Credential not found in credential wallet');

src/identity/identity-wallet.ts

@@ -31,6 +31,20 @@ export class BjjProvider implements IKeyProvider {
     this.keyType = keyType;
     this.keyStore = keyStore;
   }
+  /**
+   * get all keys
+   * @returns list of keys
+   */
+  async list(): Promise<
+    {
+      alias: string;
+      key: string;
+    }[]
+  > {
+    const allKeysFromKeyStore = await this.keyStore.list();
+    return allKeysFromKeyStore.filter((key) => key.alias.startsWith(this.keyType));
+  }
+
   /**
    * generates a baby jub jub key from a seed phrase
    * @param {Uint8Array} seed - byte array seed

src/kms/key-providers/bjj-provider.ts

@@ -21,6 +21,20 @@ export class Ed25519Provider implements IKeyProvider {
     private readonly _keyStore: AbstractPrivateKeyStore
   ) {}
 
+  /**
+   * get all keys
+   * @returns list of keys
+   */
+  async list(): Promise<
+    {
+      alias: string;
+      key: string;
+    }[]
+  > {
+    const allKeysFromKeyStore = await this._keyStore.list();
+    return allKeysFromKeyStore.filter((key) => key.alias.startsWith(this.keyType));
+  }
+
   /**
    * generates a ed25519 key from a seed phrase
    * @param {Uint8Array} seed - byte array seed

src/kms/key-providers/ed25519-provider.ts

@@ -32,6 +32,21 @@ export class Sec256k1Provider implements IKeyProvider {
     this.keyType = keyType;
     this._keyStore = keyStore;
   }
+
+  /**
+   * get all keys
+   * @returns list of keys
+   */
+  async list(): Promise<
+    {
+      alias: string;
+      key: string;
+    }[]
+  > {
+    const allKeysFromKeyStore = await this._keyStore.list();
+    return allKeysFromKeyStore.filter((key) => key.alias.startsWith(this.keyType));
+  }
+
   /**
    * generates a baby jub jub key from a seed phrase
    * @param {Uint8Array} seed - byte array seed

src/kms/key-providers/secp256k1-provider.ts

@@ -13,6 +13,18 @@ export interface IKeyProvider {
    * @type {KmsKeyType}
    */
   keyType: KmsKeyType;
+
+  /**
+   * get all keys
+   *
+   * @returns list of keys
+   */
+  list(): Promise<
+    {
+      alias: string;
+      key: string;
+    }[]
+  >;
   /**
    * gets public key by key id
    *
@@ -138,4 +150,24 @@ export class KMS {
     }
     return keyProvider.verify(data, signatureHex, keyId);
   }
+
+  /**
+   * get all keys by key type
+   *
+   * @param keyType - Key type
+   * @returns list of keys
+   */
+  list(keyType: KmsKeyType): Promise<
+    {
+      alias: string;
+      key: string;
+    }[]
+  > {
+    const keyProvider = this._registry.get(keyType);
+    if (!keyProvider) {
+      throw new Error(`keyProvider not found for: ${keyType}`);
+    }
+
+    return keyProvider.list();
+  }
 }

src/kms/kms.ts

@@ -23,4 +23,12 @@ export abstract class AbstractPrivateKeyStore {
    * @returns `Promise<string>`
    */
   abstract get(args: { alias: string }): Promise<string>;
+
+  /**
+   * get all keys
+   *
+   * @abstract
+   * @returns `Promise<{ alias: string; key: string }[]>`
+   */
+  abstract list(): Promise<{ alias: string; key: string }[]>;
 }

src/kms/store/abstract-key-store.ts

@@ -1,4 +1,4 @@
-import { UseStore, createStore, get, set } from 'idb-keyval';
+import { UseStore, createStore, get, set, entries } from 'idb-keyval';
 import { AbstractPrivateKeyStore } from './abstract-key-store';
 
 /**
@@ -19,6 +19,21 @@ export class IndexedDBPrivateKeyStore implements AbstractPrivateKeyStore {
       IndexedDBPrivateKeyStore.storageKey
     );
   }
+
+  /**
+   * get all keys
+   *
+   * @abstract
+   * @returns `Promise<{ alias: string; key: string }[]>`
+   */
+  async list(): Promise<{ alias: string; key: string }[]> {
+    const allEntries = await entries(this._store);
+    return allEntries.map(([alias, key]) => ({ alias, key: key.value })) as unknown as {
+      alias: string;
+      key: string;
+    }[];
+  }
+
   /**
    * Gets key from the indexed db storage
    *

src/kms/store/indexed-db-key-store.ts

@@ -11,6 +11,21 @@ import { KmsKeyId } from './types';
  */
 export class LocalStoragePrivateKeyStore implements AbstractPrivateKeyStore {
   static readonly storageKey = 'keystore';
+
+  /**
+   * get all keys
+   *
+   * @abstract
+   * @returns `Promise<{ alias: string; key: string }[]>`
+   */
+  list(): Promise<{ alias: string; key: string }[]> {
+    const dataStr = localStorage.getItem(LocalStoragePrivateKeyStore.storageKey);
+    if (!dataStr) {
+      throw new Error('no key under given alias');
+    }
+    const data = JSON.parse(dataStr);
+    return data.map((i: { id: string; value: string }) => ({ alias: i.id, key: i.value }));
+  }
   /**
    * Gets key from the local storage
    *

src/kms/store/local-storage-key-store.ts

@@ -12,6 +12,9 @@ export class InMemoryPrivateKeyStore implements AbstractPrivateKeyStore {
   constructor() {
     this._data = new Map<string, string>();
   }
+  list(): Promise<{ alias: string; key: string }[]> {
+    return Promise.resolve(Array.from(this._data).map(([alias, key]) => ({ alias, key })));
+  }
   async get(args: { alias: string }): Promise<string> {
     const privateKey = this._data.get(args.alias);
     if (!privateKey) {

src/kms/store/memory-key-store.ts

@@ -14,7 +14,8 @@ import {
   FSCircuitStorage,
   NativeProver,
   Iden3SparseMerkleTreeProof,
-  BJJSignatureProof2021
+  BJJSignatureProof2021,
+  TreeState
 } from '../../src';
 import {
   MOCK_STATE_STORAGE,
@@ -24,11 +25,14 @@ import {
   getInMemoryDataStorage,
   registerKeyProvidersInMemoryKMS,
   WALLET_KEY,
-  createEthereumBasedIdentity
+  createEthereumBasedIdentity,
+  SEED_ISSUER
 } from '../helpers';
 import { expect } from 'chai';
 import { Wallet } from 'ethers';
 import { getRandomBytes } from '@iden3/js-crypto';
+import { Blockchain, DidMethod, NetworkId } from '@iden3/js-iden3-core';
+import { ZERO_HASH } from '@iden3/js-merkletree';
 
 describe('identity', () => {
   let credWallet: ICredentialWallet;
@@ -192,6 +196,68 @@ describe('identity', () => {
     expect((await claimsTree.root()).bigInt()).not.to.equal(0);
   });
 
+  it('createIdentity Secp256k1 w/o auth bjj cred and add after creation', async () => {
+    const authBJJCredentialCreationOptions = {
+      seed: SEED_ISSUER,
+      revocationOpts: {
+        type: CredentialStatusType.Iden3ReverseSparseMerkleTreeProof,
+        id: RHS_URL
+      }
+    };
+    // create identity without auth bjj credential
+    const { did, credential } = await idWallet.createEthereumBasedIdentity({
+      method: DidMethod.Iden3,
+      blockchain: Blockchain.Polygon,
+      networkId: NetworkId.Amoy,
+      ...authBJJCredentialCreationOptions,
+      createBjjCredential: false
+    });
+
+    expect(did.string()).to.equal(
+      'did:iden3:polygon:amoy:x6x5sor7zpxsu478u36QvEgaRUfPjmzqFo5PHHzbM'
+    );
+    expect(credential).to.be.undefined;
+
+    // add bjj credential
+    const ethSigner = new Wallet(WALLET_KEY, dataStorage.states.getRpcProvider());
+
+    const oldTreeState: TreeState = {
+      revocationRoot: ZERO_HASH,
+      claimsRoot: ZERO_HASH,
+      state: ZERO_HASH,
+      rootOfRoots: ZERO_HASH
+    };
+
+    const credential2 = await idWallet.addBJJAuthCredential(
+      did,
+      oldTreeState,
+      true,
+      ethSigner,
+      authBJJCredentialCreationOptions
+    );
+
+    const dbCred = await dataStorage.credential.findCredentialById(credential2.id);
+    expect(credential2).to.deep.equal(dbCred);
+
+    const claimsTree = await dataStorage.mt.getMerkleTreeByIdentifierAndType(
+      did.string(),
+      MerkleTreeType.Claims
+    );
+
+    expect((await claimsTree.root()).bigInt()).not.to.equal(0);
+  });
+
+  it('createIdentity Secp256k1 with bjj cred and no signer', async () => {
+    try {
+      await createEthereumBasedIdentity(idWallet);
+      expect.fail();
+    } catch (err: unknown) {
+      expect((err as Error).message).to.be.eq(
+        `Ethereum signer is required to create Ethereum identities in order to transit state`
+      );
+    }
+  });
+
   it('add auth bjj credential', async () => {
     const { did, credential } = await createIdentity(idWallet);
     expect(did.string()).to.equal(expectedDID);

tests/identity/id.test.ts

@@ -28,6 +28,12 @@ const testFlow = async (provider: IKeyProvider) => {
     provider.newPrivateKeyFromSeed(seed2),
     provider.newPrivateKeyFromSeed(seed1)
   ]);
+
+  const providerKeys = await provider.list();
+  expect(providerKeys.length).to.equal(2);
+  expect(providerKeys[0].alias).to.include(provider.keyType);
+  expect(providerKeys[1].alias).to.include(provider.keyType);
+
   const [signature1, signature2, signature3] = await Promise.all([
     provider.sign(keyId1, dataToSign1),
     provider.sign(keyId2, dataToSign2),
@@ -56,5 +62,7 @@ describe('Key store providers', () => {
       testFlow(ed25519Provider),
       testFlow(secp256k1Provider)
     ]);
+    const allKeys = await keyStore.list();
+    expect(allKeys.length).to.equal(6);
   });
 });