src/sdk/keys.js

   1 import {createKey, resetKeyPassword, createPubkey} 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.create = function(alias, password) {
 120     var normalizedAlias = alias.toLowerCase().trim();
 121     let retPromise = new Promise((resolve, reject) => {
 122         getDB().then(db => {
 123             let getRequest = db.transaction(['keys'], 'readonly')
 124                 .objectStore('keys')
 125                 .index('alias')
 126                 .get(normalizedAlias);
 127             getRequest.onsuccess = function (e) {
 128                 if (e.target.result) {
 129                     reject(new Error('key alias already exists'));
 130                     return;
 131                 }
 132                 let data = {};
 133                 data.alias = normalizedAlias;
 134                 data.auth = password;
 135                 createKey(data).then((res) => {
 136                     let jsonData = JSON.parse(res.data);
 137                     let dbData = {
 138                         key:res.data,
 139                         xpub:jsonData.xpub,
 140                         alias:alias,
 141                     };
 142                     let request = db.transaction(['keys'], 'readwrite')
 143                         .objectStore('keys')
 144                         .add(dbData);
 145                     request.onsuccess = function () {
 146                         resolve({xpub:jsonData.xpub, alias: alias});
 147                     };
 148                     request.onerror = function () {
 149                         reject(new Error('db insert error'));
 150                     };
 151                 }).catch(error => {
 152                     reject(error);
 153                 });
 154             };
 155             getRequest.onerror = function () {
 156                 reject(new Error('db get error'));
 157             };
 158         }).catch(error => {
 159             reject(error);
 160         });
 161     });
 162     return retPromise;
 163 };
 164
 165
 166 /**
 167  * Create a new key.
 168  *
 169  * @param {String} xpub - xpub.
 170  */
 171 keysSDK.prototype.createPubkey = function(xpub) {
 172     let retPromise = new Promise((resolve, reject) => {
 173         let data = {};
 174         data.xpub = xpub;
 175         data.seed = 1;
 176         createPubkey(data).then((res) => {
 177             let jsonData = JSON.parse(res.data);
 178             resolve(jsonData);
 179         }).catch(error => {
 180             reject(error);
 181         });
 182     });
 183     return retPromise;
 184 };
 185
 186 export default keysSDK;