src/sdk/keys.js

   1 import { createKey ,resetKeyPassword, createPubkey, signMessage, signTransaction} from '../wasm/func';
   2 import {getDB} from '../db/db';
   3 import {createkey, isValidMnemonic} 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     return res;
 149 };
 150
 151 /**
 152  * Create a new key.
 153  *
 154  * @param {String} alias - User specified, unique identifier.
 155  * @param {String} password - User specified, key password.
 156  */
 157 keysSDK.prototype.restoreFromKeystore = function( password, keystore) {
 158
 159     const walletImage = JSON.parse(keystore);
 160
 161     let keys, key;
 162     if(walletImage.key_images && walletImage.key_images.xkeys ){
 163         keys = walletImage.key_images.xkeys;
 164     }
 165
 166     // match older version of backups keystore files
 167     else if(walletImage.keys>0){
 168         keys = walletImage.keys.map(keyItem => JSON.parse( keyItem.key ) );
 169     }else{
 170         key  = walletImage;
 171     }
 172
 173     if(keys.length>1){
 174         throw 'do not support multiple keystore imported.';
 175     }
 176     else if(keys.length === 1){
 177         key = keys[0];
 178     }
 179
 180     const result = decryptKey(key, password);
 181
 182     return result;
 183 };
 184
 185 /**
 186  * Create a new key.
 187  *
 188  * @param {String} alias - User specified, unique identifier.
 189  * @param {String} password - User specified, key password.
 190  */
 191 keysSDK.prototype.isValidMnemonic = function(mnemonic) {
 192
 193     return isValidMnemonic(mnemonic);
 194 };
 195
 196 /**
 197  * Create a new key.
 198  *
 199  * @param {String} alias - User specified, unique identifier.
 200  * @param {String} password - User specified, key password.
 201  */
 202 keysSDK.prototype.create = function(alias, password) {
 203     var normalizedAlias = alias.toLowerCase().trim();
 204     let retPromise = new Promise((resolve, reject) => {
 205         getDB().then(db => {
 206             let getRequest = db.transaction(['keys'], 'readonly')
 207                 .objectStore('keys')
 208                 .index('alias')
 209                 .get(normalizedAlias);
 210             getRequest.onsuccess = function (e) {
 211                 if (e.target.result) {
 212                     reject(new Error('key alias already exists'));
 213                     return;
 214                 }
 215                 let data = {};
 216                 data.alias = normalizedAlias;
 217                 data.auth = password;
 218                 createKey(data).then((res) => {
 219                     let jsonData = JSON.parse(res.data);
 220                     let dbData = {
 221                         key:res.data,
 222                         xpub:jsonData.xpub,
 223                         alias:alias,
 224                     };
 225                     let request = db.transaction(['keys'], 'readwrite')
 226                         .objectStore('keys')
 227                         .add(dbData);
 228                     request.onsuccess = function () {
 229                         resolve({xpub:jsonData.xpub, alias: alias});
 230                     };
 231                     request.onerror = function () {
 232                         reject(new Error('db insert error'));
 233                     };
 234                 }).catch(error => {
 235                     reject(error);
 236                 });
 237             };
 238             getRequest.onerror = function () {
 239                 reject(new Error('db get error'));
 240             };
 241         }).catch(error => {
 242             reject(error);
 243         });
 244     });
 245     return retPromise;
 246 };
 247
 248
 249 /**
 250  * Create a new key.
 251  *
 252  * @param {String} xpub - xpub.
 253  */
 254 keysSDK.prototype.createPubkey = function(xpub) {
 255     let retPromise = new Promise((resolve, reject) => {
 256         let data = {};
 257         data.xpub = xpub;
 258         data.seed = 1;
 259         createPubkey(data).then((res) => {
 260             let jsonData = JSON.parse(res.data);
 261             resolve(jsonData);
 262         }).catch(error => {
 263             reject(error);
 264         });
 265     });
 266     return retPromise;
 267 };
 268
 269 /**
 270  * Sign Message.
 271  *
 272  * @param {String} message - message.
 273  * @param {String} password - password.
 274  * @param {Object} address - address.
 275  */
 276 keysSDK.prototype.signMessage = function(message, password, address) {
 277     let retPromise = new Promise((resolve, reject) => {
 278         getDB().then(db => {
 279             let getRequest = db.transaction(['accounts-server'], 'readonly')
 280                 .objectStore('accounts-server')
 281                 .getAll();
 282
 283             getRequest.onsuccess = function (e) {
 284                 const result = getRequest.result.filter(obj => (obj.address === address || obj.vpAddress === address));
 285                 if (result.length === 0) {
 286                     reject(new Error('not found address'));
 287                     return;
 288                 }
 289
 290                 const rootXpub = result[0].rootXPub;
 291                 let keyObject = db.transaction(['keys'], 'readonly')
 292                     .objectStore('keys')
 293                     .index('xpub')
 294                     .get(rootXpub);
 295
 296                 keyObject.onsuccess = function (e) {
 297                     if (!e.target.result) {
 298                         reject(new Error('not found xpub'));
 299                         return;
 300                     }
 301
 302                     let data = {};
 303                     data.message = message;
 304                     data.password = password;
 305                     data.key = e.target.result.key;
 306                     signMessage(data).then((res) => {
 307                         let jsonData = JSON.parse(res.data);
 308                         resolve(jsonData);
 309                     }).catch(error => {
 310                         reject(error);
 311                     });
 312                 };
 313                 keyObject.onerror = function () {
 314                     reject(getRequest.error);
 315                 };
 316             };
 317             getRequest.onerror = function () {
 318                 reject(getRequest.error);
 319             };
 320         }).catch(error => {
 321             reject(error);
 322         });
 323     });
 324     return retPromise;
 325 };
 326
 327 export default keysSDK;