src/sdk/keys.js

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