src/sdk/keys.js

   1 import { createKey ,resetKeyPassword, createPubkey, signMessage, signTransaction} from '../wasm/func';
   2 import {getDB} from '../db/db';
   3 import {createkey} from '../utils/key/createKey';
   4 import {encryptKey, decryptKey} from '../utils/key/keystore';
   5 import { restoreFromKeyStore } from '../utils/account';
   6
   7
   8 function keysSDK() {
   9 }
  10
  11 /**
  12  * reset key password
  13  *
  14  * @param {String}} rootXPub
  15  * @param {String} oldPassword
  16  * @param {String} newPassword
  17  */
  18 keysSDK.prototype.resetKeyPassword = function(rootXPub, oldPassword, newPassword) {
  19     let retPromise = new Promise((resolve, reject) => {
  20         let data = {rootXPub: rootXPub, oldPassword:oldPassword, newPassword:newPassword};
  21         resetKeyPassword(data).then(res => {
  22             getDB().then(db => {
  23                 let objectStore = db.transaction(['keys'], 'readwrite').objectStore('keys');
  24                 let index = objectStore.index('xpub');
  25                 let keyRange = IDBKeyRange.only(rootXPub);
  26                 let getRequest = index.openCursor(keyRange);
  27                 getRequest.onsuccess = function (event) {
  28                     const cursor = event.target.result;
  29                     if(cursor && cursor.value.xpub === rootXPub) {
  30                         const updateData = cursor.value;
  31                         updateData.key = res.data;
  32                         const request = cursor.update(updateData);
  33                         request.onsuccess = function() {
  34                             resolve(true);
  35                         };
  36                         request.onerror = function() {
  37                             reject(new Error('db update error'));
  38                         };
  39                     } else {
  40                         reject(new Error('db update error: not found by rootXPub'));
  41                     }
  42                 };
  43                 getRequest.onerror = function () {
  44                     reject(new Error('db get error'));
  45                 };
  46             }).catch(error => {
  47                 reject(error);
  48             });
  49         }).catch(error => {
  50             reject(error);
  51         });
  52     });
  53     return retPromise;
  54 };
  55
  56 /**
  57  * get key by XPub
  58  *
  59  * @param {String} xpub
  60  */
  61 keysSDK.prototype.getKeyByXPub = function(xpub) {
  62     let retPromise = new Promise((resolve, reject) => {
  63         getDB().then(db => {
  64             let getRequest = db.transaction(['keys'], 'readonly')
  65                 .objectStore('keys')
  66                 .index('xpub')
  67                 .get(xpub);
  68             getRequest.onsuccess = function(e) {
  69                 if(e.target.result) {
  70                     resolve(e.target.result.key);
  71                 } else {
  72                     reject(new Error('not found by XPub'));
  73                 }
  74             };
  75             getRequest.onerror = function() {
  76                 reject(new Error('db get error'));
  77             };
  78         }).catch(error => {
  79             reject(error);
  80         });
  81     });
  82     return retPromise;
  83 };
  84
  85 /**
  86  * List key
  87  *
  88  * @returns {Promise}
  89  */
  90 keysSDK.prototype.list = function() {
  91     let retPromise = new Promise((resolve, reject) => {
  92         getDB().then(db => {
  93             let transaction = db.transaction(['keys'], 'readonly');
  94             let objectStore = transaction.objectStore('keys');
  95             let oc = objectStore.openCursor();
  96             let ret = [];
  97             oc.onsuccess = function (event) {
  98                 var cursor = event.target.result;
  99                 if (cursor) {
 100                     ret.push({alias: cursor.value.alias, xpub: cursor.value.xpub});
 101                     cursor.continue();
 102                 } else {
 103                     resolve(ret);
 104                 }
 105             };
 106             oc.onerror = function(e){
 107                 reject(e);
 108             };
 109         }).catch(err => {
 110             reject(err);
 111         });
 112     });
 113     return retPromise;
 114 };
 115
 116 /**
 117  * Create a new key.
 118  *
 119  * @param {String} alias - User specified, unique identifier.
 120  * @param {String} password - User specified, key password.
 121  */
 122 keysSDK.prototype.createKey = function(alias, password) {
 123     var normalizedAlias = alias.toLowerCase().trim();
 124
 125     let data = {};
 126     data.alias = normalizedAlias;
 127     data.password = password;
 128     const res = createkey(data);
 129     return res;
 130 };
 131
 132 /**
 133  * Create a new key.
 134  *
 135  * @param {String} alias - User specified, unique identifier.
 136  * @param {String} password - User specified, key password.
 137  */
 138 keysSDK.prototype.restoreFromMnemonic = function(alias, password, mnemonic) {
 139     var normalizedAlias = alias.toLowerCase().trim();
 140
 141     let data = {};
 142     data.alias = normalizedAlias;
 143     data.password = password;
 144     data.mnemonic = mnemonic;
 145
 146     const res = createkey(data);
 147
 148     const xpub = res.xpub;
 149
 150     //Todo: /account/wallets api find if xpub exist in the blockcenter, yes restore, otherwise create new account
 151
 152     return res;
 153 };
 154
 155 /**
 156  * Create a new key.
 157  *
 158  * @param {String} alias - User specified, unique identifier.
 159  * @param {String} password - User specified, key password.
 160  */
 161 keysSDK.prototype.create = function(alias, password) {
 162     var normalizedAlias = alias.toLowerCase().trim();
 163     let retPromise = new Promise((resolve, reject) => {
 164         getDB().then(db => {
 165             let getRequest = db.transaction(['keys'], 'readonly')
 166                 .objectStore('keys')
 167                 .index('alias')
 168                 .get(normalizedAlias);
 169             getRequest.onsuccess = function (e) {
 170                 if (e.target.result) {
 171                     reject(new Error('key alias already exists'));
 172                     return;
 173                 }
 174                 let data = {};
 175                 data.alias = normalizedAlias;
 176                 data.auth = password;
 177                 createKey(data).then((res) => {
 178                     let jsonData = JSON.parse(res.data);
 179                     let dbData = {
 180                         key:res.data,
 181                         xpub:jsonData.xpub,
 182                         alias:alias,
 183                     };
 184                     let request = db.transaction(['keys'], 'readwrite')
 185                         .objectStore('keys')
 186                         .add(dbData);
 187                     request.onsuccess = function () {
 188                         resolve({xpub:jsonData.xpub, alias: alias});
 189                     };
 190                     request.onerror = function () {
 191                         reject(new Error('db insert error'));
 192                     };
 193                 }).catch(error => {
 194                     reject(error);
 195                 });
 196             };
 197             getRequest.onerror = function () {
 198                 reject(new Error('db get error'));
 199             };
 200         }).catch(error => {
 201             reject(error);
 202         });
 203     });
 204     return retPromise;
 205 };
 206
 207
 208 /**
 209  * Create a new key.
 210  *
 211  * @param {String} xpub - xpub.
 212  */
 213 keysSDK.prototype.createPubkey = function(xpub) {
 214     let retPromise = new Promise((resolve, reject) => {
 215         let data = {};
 216         data.xpub = xpub;
 217         data.seed = 1;
 218         createPubkey(data).then((res) => {
 219             let jsonData = JSON.parse(res.data);
 220             resolve(jsonData);
 221         }).catch(error => {
 222             reject(error);
 223         });
 224     });
 225     return retPromise;
 226 };
 227
 228 /**
 229  * Sign Message.
 230  *
 231  * @param {String} message - message.
 232  * @param {String} password - password.
 233  * @param {Object} address - address.
 234  */
 235 keysSDK.prototype.signMessage = function(message, password, address) {
 236     let retPromise = new Promise((resolve, reject) => {
 237         getDB().then(db => {
 238             let getRequest = db.transaction(['accounts-server'], 'readonly')
 239                 .objectStore('accounts-server')
 240                 .getAll();
 241
 242             getRequest.onsuccess = function (e) {
 243                 const result = getRequest.result.filter(obj => (obj.address === address || obj.vpAddress === address));
 244                 if (result.length === 0) {
 245                     reject(new Error('not found address'));
 246                     return;
 247                 }
 248
 249                 const rootXpub = result[0].rootXPub;
 250                 let keyObject = db.transaction(['keys'], 'readonly')
 251                     .objectStore('keys')
 252                     .index('xpub')
 253                     .get(rootXpub);
 254
 255                 keyObject.onsuccess = function (e) {
 256                     if (!e.target.result) {
 257                         reject(new Error('not found xpub'));
 258                         return;
 259                     }
 260
 261                     let data = {};
 262                     data.message = message;
 263                     data.password = password;
 264                     data.key = e.target.result.key;
 265                     signMessage(data).then((res) => {
 266                         let jsonData = JSON.parse(res.data);
 267                         resolve(jsonData);
 268                     }).catch(error => {
 269                         reject(error);
 270                     });
 271                 };
 272                 keyObject.onerror = function () {
 273                     reject(getRequest.error);
 274                 };
 275             };
 276             getRequest.onerror = function () {
 277                 reject(getRequest.error);
 278             };
 279         }).catch(error => {
 280             reject(error);
 281         });
 282     });
 283     return retPromise;
 284 };
 285
 286 export default keysSDK;