Merge pull request #26 from CityOfZion/CU-86a1jh86w

CU-86a1jh86w - Implement method to encrypt a private key

packages/blockchain-service/src/interfaces.ts

@@ -53,6 +53,7 @@ export interface BlockchainService<BSCustomName extends string = string> {
   generateAccountFromMnemonic(mnemonic: string | string, index: number): AccountWithDerivationPath
   generateAccountFromKey(key: string): Account
   decrypt(keyOrJson: string, password: string): Promise<Account>
+  encrypt(key: string, password: string): Promise<string>
   validateAddress(address: string): boolean
   validateEncrypted(keyOrJson: string): boolean
   validateKey(key: string): boolean

packages/bs-ethereum/src/BSEthereum.ts

@@ -118,6 +118,11 @@ export class BSEthereum<BSCustomName extends string = string>
     }
   }
 
+  async encrypt(key: string, password: string): Promise<string> {
+    const wallet = new ethers.Wallet(key)
+    return wallet.encrypt(password)
+  }
+
   async transfer({ senderAccount, intent }: TransferParam): Promise<string> {
     const provider = new ethers.providers.JsonRpcProvider(this.network.url)
     const wallet = new ethers.Wallet(senderAccount.key, provider)

packages/bs-ethereum/src/__tests__/BSEthereum.spec.ts

@@ -63,11 +63,17 @@ describe('BSEthereum', () => {
 
   it('Should be able to decrypt a encrypted key', async () => {
     const password = 'TestPassword'
-    const validEncryptedJson = await wallet.encrypt(password)
+    const validEncryptedJson = await bsEthereum.encrypt(wallet.privateKey, password)
     const decryptedAccount = await bsEthereum.decrypt(validEncryptedJson, password)
     expect(decryptedAccount).toEqual(account)
   })
 
+  it('Should be able to encrypt key', async () => {
+    const password = 'TestPassword'
+    const validEncryptedJson = await bsEthereum.encrypt(wallet.privateKey, password)
+    expect(validEncryptedJson).toEqual(expect.objectContaining({ address: wallet.address }))
+  })
+
   it.skip('Should be able to calculate transfer fee', async () => {
     const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
 

packages/bs-neo-legacy/src/BSNeoLegacy.ts

@@ -116,6 +116,10 @@ export class BSNeoLegacy<BSCustomName extends string = string>
     return this.generateAccountFromKey(privateKey)
   }
 
+  encrypt(key: string, password: string): Promise<string> {
+    return wallet.encrypt(key, password)
+  }
+
   async transfer({ intent: transferIntent, senderAccount, tipIntent, ...params }: TransferParam): Promise<string> {
     const apiProvider = new api.neoCli.instance(this.network.url)
     const account = new wallet.Account(senderAccount.key)

packages/bs-neo-legacy/src/__tests__/BSNeoLegacy.spec.ts

@@ -53,11 +53,19 @@ describe('BSNeoLegacy', () => {
     const mnemonic = generateMnemonic()
     const account = bsNeoLegacy.generateAccountFromMnemonic(mnemonic, 0)
     const password = 'TestPassword'
-    const encryptedKey = await wallet.encrypt(account.key, password)
+    const encryptedKey = await bsNeoLegacy.encrypt(account.key, password)
     const decryptedAccount = await bsNeoLegacy.decrypt(encryptedKey, password)
     expect(account).toEqual(expect.objectContaining(decryptedAccount))
   }, 10000)
 
+  it('Should be able to encrypt a key', async () => {
+    const mnemonic = generateMnemonic()
+    const account = bsNeoLegacy.generateAccountFromMnemonic(mnemonic, 0)
+    const password = 'TestPassword'
+    const encryptedKey = await bsNeoLegacy.encrypt(account.key, password)
+    expect(encryptedKey).toEqual(expect.any(String))
+  })
+
   it.skip('Should be able to transfer a native asset', async () => {
     const account = bsNeoLegacy.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
     const balance = await bsNeoLegacy.blockchainDataService.getBalance(account.address)

packages/bs-neo3/src/BSNeo3.ts

@@ -130,6 +130,10 @@ export class BSNeo3<BSCustomName extends string = string>
     return this.generateAccountFromKey(privateKey)
   }
 
+  encrypt(key: string, password: string): Promise<string> {
+    return wallet.encrypt(key, password)
+  }
+
   async calculateTransferFee(param: TransferParam): Promise<string> {
     const account = new wallet.Account(param.senderAccount.key)
     const invoker = await NeonInvoker.init({

packages/bs-neo3/src/__tests__/BSNeo3.spec.ts

@@ -69,11 +69,19 @@ describe('BSNeo3', () => {
     const mnemonic = generateMnemonic()
     const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
     const password = 'TestPassword'
-    const encryptedKey = await wallet.encrypt(account.key, password)
+    const encryptedKey = await bsNeo3.encrypt(account.key, password)
     const decryptedAccount = await bsNeo3.decrypt(encryptedKey, password)
     expect(account).toEqual(expect.objectContaining(decryptedAccount))
   }, 20000)
 
+  it('Should be able to encrypt a key', async () => {
+    const mnemonic = generateMnemonic()
+    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
+    const password = 'TestPassword'
+    const encryptedKey = await bsNeo3.encrypt(account.key, password)
+    expect(encryptedKey).toEqual(expect.any(String))
+  })
+
   it.skip('Should be able to calculate transfer fee', async () => {
     const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)