bank-client-js/src/index.ts

import crypto = require('libp2p-crypto');
import util = require('util');
import RsaPrivateKey = crypto.keys;
import { Storage } from './storage';
import { IWebClient } from './webclient';
const TextEncoder = util.TextEncoder;

import { encodeHex } from './util';
import WebClientNode from './webclient-node';

export class BankClient {

    private privateKey: RsaPrivateKey | undefined;
    private bootstrapPromise: any;
    private bootstrapResult: any;

    constructor(private urlBase: string, private storage: Storage = new Storage('bankClient'), private webClient: IWebClient = new WebClientNode()) {

    }

    public getPub(): Promise<string> {
      return new Promise(async (resolve, reject) => {
        await this.bootstrap();
        this.getPriv().id((idErr, pubHash) => {
          if (idErr) {
            return reject(idErr);
          }
          resolve(pubHash);
        });
      });
    }
  
    public bootstrap() {
      if (this.bootstrapResult) {
        return Promise.resolve(this.bootstrapResult);
      }
      if (this.bootstrapPromise) {
        return this.bootstrapPromise;
      }
      return this.bootstrapPromise = new Promise((resolve, reject) => {
        this.storage.get('notaprivatekey').then(privateKeyFromStorage => {
          if (privateKeyFromStorage == null) {
            console.log('no private key in storage. generating new');
            crypto.keys.generateKeyPair('RSA', 2048, (generateErr, privateKey) => {
              if (generateErr) {
                return reject(generateErr);
              }
              privateKey.export('password', (exportErr, exportResult) => {
                if (exportErr) {
                  return reject(exportErr);
                }
                this.storage.set('notaprivatekey', exportResult).then(err => {
                    // whatever
                }).catch(reject);
                this.privateKey = privateKey;
                resolve(true);
              });
            });
          } else {
            // console.log('importing privatekey');
            crypto.keys.import(privateKeyFromStorage, 'password', (err, importedPrivateKey) => {
              if (err) {
                return reject(err);
              }
              this.privateKey = importedPrivateKey;
              // console.log(this.getPublicKeyString());
              // console.log(privateKeyFromStorage);
              resolve(true);
            });
          }
        }).catch(reject);
      });
    }
  
    public async getNonce() {
      const nonce = await this.webClient.request({
        method: 'GET',
        url: this.urlBase + '/bank/nonce'
      });
      return Number(nonce);
    }

    public async getBalance(): Promise<number> {
      const nonce = await this.getNonce();
      const retrieveRequest = await this.makePlaintextPayload(JSON.stringify({
        _date: new Date().toISOString(),
        _nonce: nonce
      }));
  
      const topicURL = this.urlBase + '/bank/getbalance';
      const postResponse:any = await this.webClient.requestJSON({
        body: retrieveRequest,
        method: 'POST',
        url: topicURL
      });
      console.log('postResponse', postResponse);
      return postResponse.balance;
    }



    private getPriv(): RsaPrivateKey {
      if (!this.privateKey) {
        throw new Error('missing private key');
      }
      return this.privateKey;
    }

    private makePlaintextPayload(message: string) {
      const messageBytes = new TextEncoder().encode(message);
  
      return new Promise(async (resolve, reject) => {
        await this.bootstrap();
        this.privateKey.sign(messageBytes, async (signErr, signatureBytes) => {
          if (signErr) {
            reject(signErr);
            return;
          }
          const publicDERBytes = this.privateKey.public.bytes;
          this.privateKey.id((idErr, pubHash) => {
            if (idErr) {
              reject(idErr);
              return;
            }
            const result = {
              date: new Date().toISOString(),
              msg: encodeHex(messageBytes),
              pub: encodeHex(publicDERBytes),
              pubHash,
              sig: encodeHex(signatureBytes),
            };
            // console.log('result', result, signatureBytes);
            resolve(result);
          });
        });
      });
    }
}