JS keystore support

dependency-graph.json

@@ -202,6 +202,13 @@
       "@celo/wallet-local"
     ]
   },
+  "@celo/keystores": {
+    "location": "packages/sdk/keystores",
+    "dependencies": [
+      "@celo/utils",
+      "@celo/wallet-local"
+    ]
+  },
   "@celo/network-utils": {
     "location": "packages/sdk/network-utils",
     "dependencies": [

packages/sdk/keystores/.gitignore

@@ -0,0 +1,2 @@
+lib/
+test-keystore-dir/

packages/sdk/keystores/.npmignore

@@ -0,0 +1,17 @@
+/.devchain/
+/.devchain.tar.gz
+/coverage/
+/node_modules/
+/src/
+/tmp/
+/.tmp/
+
+/tslint.json
+/tsconfig.*
+/jest.config.*
+*.tgz
+
+/src
+
+/lib/**/*.test.*
+/lib/test-utils

packages/sdk/keystores/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['<rootDir>/src/**/?(*.)+(spec|test).ts?(x)'],
+}

packages/sdk/keystores/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@celo/keystores",
+  "version": "1.2.2-dev",
+  "description": "keystore implementation",
+  "author": "Celo",
+  "license": "Apache-2.0",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "keywords": [
+    "celo",
+    "blockchain",
+    "sdk"
+  ],
+  "scripts": {
+    "build": "tsc -b .",
+    "clean": "tsc -b . --clean",
+    "docs": "typedoc && ts-node ../utils/scripts/linkdocs.ts keystores",
+    "test": "jest --runInBand",
+    "lint": "tslint -c tslint.json --project .",
+    "prepublishOnly": "yarn build"
+  },
+  "dependencies": {
+    "@celo/utils": "1.2.2-dev",
+    "@celo/wallet-local": "1.2.2-dev",
+    "@types/ethereumjs-util": "^5.2.0",
+    "ethereumjs-wallet": "^1.0.1"
+  },
+  "engines": {
+    "node": ">=10"
+  }
+}

packages/sdk/keystores/src/file-keystore.test.ts

@@ -0,0 +1,50 @@
+import { trimLeading0x } from '@celo/utils/lib/address'
+import { mkdirSync, readdirSync, readFileSync, rmdirSync, writeFileSync } from 'fs'
+import path from 'path'
+import { FileKeystore } from './file-keystore'
+import { ADDRESS1, GETH_GEN_KEYSTORE1, KEYSTORE_NAME1, PASSPHRASE1, PK1 } from './test-constants'
+
+jest.setTimeout(20000)
+
+describe('FileKeystore tests', () => {
+  const parentWorkdir = path.join(__dirname, 'wallet-keystore-workdir')
+  let testWorkdir: string
+
+  beforeAll(() => {
+    mkdirSync(parentWorkdir, { recursive: true })
+  })
+
+  beforeEach(() => {
+    testWorkdir = path.join(parentWorkdir, `test-${Math.random().toString(36).substring(2, 7)}`)
+    mkdirSync(testWorkdir)
+  })
+
+  afterAll(() => {
+    rmdirSync(parentWorkdir, { recursive: true })
+  })
+  it('initializes keystore, imports key into keystore file, and deletes', async () => {
+    const keystore = new FileKeystore(testWorkdir)
+    expect(readdirSync(testWorkdir)).toEqual(['keystore'])
+    const keystorePath = path.join(testWorkdir, 'keystore')
+    expect(readdirSync(keystorePath).length).toBe(0)
+    await keystore.importPrivateKey(PK1, PASSPHRASE1)
+    const keystoreFiles = readdirSync(keystorePath)
+    expect(keystoreFiles.length).toBe(1)
+    const keystoreName = await keystore.getKeystoreName(ADDRESS1)
+    expect(readFileSync(path.join(keystorePath, keystoreFiles[0])).toString()).toEqual(
+      keystore.getRawKeystore(keystoreName)
+    )
+    keystore.removeKeystore(keystoreName)
+    expect(readdirSync(keystorePath).length).toBe(0)
+  })
+
+  it('reads key from file in existing keystore', async () => {
+    const keystorePath = path.join(testWorkdir, 'keystore')
+    mkdirSync(keystorePath)
+    writeFileSync(path.join(keystorePath, KEYSTORE_NAME1), GETH_GEN_KEYSTORE1)
+    const keystore = new FileKeystore(testWorkdir)
+    expect(await keystore.getAllKeystoreNames()).toEqual([KEYSTORE_NAME1])
+    expect(await keystore.listKeystoreAddresses()).toEqual([ADDRESS1])
+    expect(trimLeading0x(await keystore.getPrivateKey(ADDRESS1, PASSPHRASE1))).toEqual(PK1)
+  })
+})

packages/sdk/keystores/src/file-keystore.ts

@@ -0,0 +1,56 @@
+import { mkdirSync, promises as fsPromises, readFileSync, unlinkSync, writeFileSync } from 'fs'
+import path from 'path'
+import { KeystoreBase } from './keystore-base'
+
+export class FileKeystore extends KeystoreBase {
+  /**
+   * Implements keystore as a directory on disk
+   * with files for keystore entries
+   */
+  private _keystoreDir: string
+
+  /**
+   * Creates (but does not overwrite existing) directory
+   * for containing keystore entries.
+   * @param keystoreDir Path to directory where keystore will be saved
+   */
+  constructor(keystoreDir: string) {
+    super()
+    this._keystoreDir = path.join(keystoreDir, 'keystore')
+    // Does not overwrite existing directories
+    mkdirSync(this._keystoreDir, { recursive: true })
+  }
+
+  /**
+   * @returns List of file names (keystore entries) in the keystore
+   */
+  async getAllKeystoreNames(): Promise<string[]> {
+    return fsPromises.readdir(this._keystoreDir)
+  }
+
+  /**
+   * Saves keystore entries as a file in the keystore directory
+   * @param keystoreName File name of keystore entry
+   * @param keystore V3Keystore string entry
+   */
+  persistKeystore(keystoreName: string, keystore: string) {
+    writeFileSync(path.join(this._keystoreDir, keystoreName), keystore)
+  }
+
+  /**
+   * Gets contents of keystore entry file
+   * @param keystoreName File name of keystore entry
+   * @returns V3Keystore string entry
+   */
+  getRawKeystore(keystoreName: string): string {
+    return readFileSync(path.join(this._keystoreDir, keystoreName)).toString()
+  }
+
+  /**
+   * Deletes file keystore entry from directory
+   * @param keystoreName File name of keystore entry to be removed
+   */
+  removeKeystore(keystoreName: string) {
+    return unlinkSync(path.join(this._keystoreDir, keystoreName))
+  }
+}

packages/sdk/keystores/src/index.ts

@@ -0,0 +1,4 @@
+export * from './file-keystore'
+export * from './inmemory-keystore'
+export * from './keystore-base'
+export * from './keystore-wallet-wrapper'

packages/sdk/keystores/src/inmemory-keystore.ts

@@ -0,0 +1,25 @@
+import { KeystoreBase } from './keystore-base'
+
+export class InMemoryKeystore extends KeystoreBase {
+  /**
+   * Used for mocking keystore operations in unit tests
+   */
+  private _storage: Record<string, string> = {}
+
+  // Implements required abstract class methods
+  persistKeystore(keystoreName: string, keystore: string) {
+    this._storage[keystoreName] = keystore
+  }
+
+  getRawKeystore(keystoreName: string): string {
+    return this._storage[keystoreName]
+  }
+
+  async getAllKeystoreNames(): Promise<string[]> {
+    return Object.keys(this._storage)
+  }
+
+  removeKeystore(keystoreName: string) {
+    delete this._storage[keystoreName]
+  }
+}

packages/sdk/keystores/src/keystore-base.test.ts

@@ -0,0 +1,97 @@
+import { privateKeyToAddress, trimLeading0x } from '@celo/utils/lib/address'
+import { InMemoryKeystore } from './inmemory-keystore'
+import { ErrorMessages } from './keystore-base'
+import {
+  ADDRESS1,
+  ADDRESS2,
+  GETH_GEN_KEYSTORE1,
+  GETH_GEN_KEYSTORE2,
+  KEYSTORE_NAME1,
+  KEYSTORE_NAME2,
+  PASSPHRASE1,
+  PASSPHRASE2,
+  PK1,
+} from './test-constants'
+
+jest.setTimeout(20000)
+
+describe('KeystoreBase functionality via InMemoryKeystore (mock)', () => {
+  let keystore: InMemoryKeystore
+  beforeEach(() => {
+    keystore = new InMemoryKeystore()
+  })
+
+  describe('checks with an empty keystore', () => {
+    it('lists no addresses', async () => {
+      expect(await keystore.listKeystoreAddresses()).toEqual([])
+    })
+    it('imports keystore (can decrypt, can list addresses)', async () => {
+      await keystore.importPrivateKey(PK1, PASSPHRASE1)
+      expect(await keystore.listKeystoreAddresses()).toEqual([ADDRESS1])
+      expect(trimLeading0x(await keystore.getPrivateKey(ADDRESS1, PASSPHRASE1))).toEqual(PK1)
+    })
+    it('gets empty address map', async () => {
+      expect(await keystore.getAddressMap()).toEqual({})
+    })
+    it('fails when address is not in the keystore', async () => {
+      await expect(keystore.getPrivateKey(ADDRESS1, PK1)).rejects.toThrow(
+        ErrorMessages.NO_MATCHING_ENTRY
+      )
+    })
+  })
+
+  describe('checks with a populated keystore', () => {
+    beforeEach(() => {
+      keystore.persistKeystore(KEYSTORE_NAME1, GETH_GEN_KEYSTORE1)
+    })
+
+    it('decrypts and returns raw private key from keystore blob', async () => {
+      expect(trimLeading0x(await keystore.getPrivateKey(ADDRESS1, PASSPHRASE1))).toBe(PK1)
+    })
+
+    it('decrypts when non-normalized address is passed in', async () => {
+      expect(
+        trimLeading0x(await keystore.getPrivateKey(privateKeyToAddress(PK1), PASSPHRASE1))
+      ).toBe(PK1)
+    })
+
+    it('does not decrypt keystore with incorrect passphrase', async () => {
+      await expect(keystore.getPrivateKey(ADDRESS1, PASSPHRASE1 + '!')).rejects.toThrow(
+        'Key derivation failed - possibly wrong passphrase'
+      )
+    })
+
+    it('gets keystore name from address', async () => {
+      expect(await keystore.getKeystoreName(ADDRESS1)).toBe(KEYSTORE_NAME1)
+    })
+
+    it('changes keystore passphrase successfully', async () => {
+      await keystore.changeKeystorePassphrase(ADDRESS1, PASSPHRASE1, PASSPHRASE2)
+      await expect(keystore.getPrivateKey(ADDRESS1, PASSPHRASE1)).rejects.toThrow()
+      expect(trimLeading0x(await keystore.getPrivateKey(ADDRESS1, PASSPHRASE2))).toBe(PK1)
+    })
+
+    it('does not import same private key twice', async () => {
+      await expect(keystore.importPrivateKey(PK1, PASSPHRASE2)).rejects.toThrow(
+        ErrorMessages.KEYSTORE_ENTRY_EXISTS
+      )
+    })
+
+    it('lists addresses', async () => {
+      expect(await keystore.listKeystoreAddresses()).toEqual([ADDRESS1])
+    })
+
+    it('deletes keystore', async () => {
+      await keystore.deleteKeystore(ADDRESS1)
+      expect(await keystore.listKeystoreAddresses()).toEqual([])
+    })
+
+    it('maps address to keystore name', async () => {
+      keystore.persistKeystore(KEYSTORE_NAME2, GETH_GEN_KEYSTORE2)
+      const expectedMap: Record<string, string> = {}
+      expectedMap[ADDRESS1] = KEYSTORE_NAME1
+      expectedMap[ADDRESS2] = KEYSTORE_NAME2
+      expect(await keystore.getAddressMap()).toEqual(expectedMap)
+    })
+  })
+})