src/sdk/keys.js

   1 import {createKey, resetKeyPassword, createPubkey} from '../wasm/func';
   2 import {getDB} from '../db/db';
   3
   4
   5 /**
   6  * Represents a keysSDK.
   7  * @constructor
   8  */
   9 function keysSDK() {
  10 }
  11
  12 /**
  13  * reset key password
  14  *
  15  * @param {String}} rootXPub
  16  * @param {String} oldPassword
  17  * @param {String} newPassword
  18  */
  19 keysSDK.prototype.resetKeyPassword = function(rootXPub, oldPassword, newPassword) {
  20     let retPromise = new Promise((resolve, reject) => {
  21         let data = {rootXPub: rootXPub, oldPassword:oldPassword, newPassword:newPassword};
  22         resetKeyPassword(data).then(res => {
  23             getDB().then(db => {
  24                 let objectStore = db.transaction(['keys'], 'readwrite').objectStore('keys');
  25                 let index = objectStore.index('xpub');
  26                 let keyRange = IDBKeyRange.only(rootXPub);
  27                 let getRequest = index.openCursor(keyRange);
  28                 getRequest.onsuccess = function (event) {
  29                     const cursor = event.target.result;
  30                     if(cursor && cursor.value.xpub === rootXPub) {
  31                         const updateData = cursor.value;
  32                         updateData.key = res.data;
  33                         const request = cursor.update(updateData);
  34                         request.onsuccess = function() {
  35                             resolve(true);
  36                         };
  37                         request.onerror = function() {
  38                             reject(new Error('db update error'));
  39                         };
  40                     } else {
  41                         reject(new Error('db update error: not found by rootXPub'));
  42                     }
  43                 };
  44                 getRequest.onerror = function () {
  45                     reject(new Error('db get error'));
  46                 };
  47             }).catch(error => {
  48                 reject(error);
  49             });
  50         }).catch(error => {
  51             reject(error);
  52         });
  53     });
  54     return retPromise;
  55 };
  56
  57 /**
  58  * get key by XPub
  59  *
  60  * @param {String} xpub
  61  */
  62 keysSDK.prototype.getKeyByXPub = function(xpub) {
  63     let retPromise = new Promise((resolve, reject) => {
  64         getDB().then(db => {
  65             let getRequest = db.transaction(['keys'], 'readonly')
  66                 .objectStore('keys')
  67                 .index('xpub')
  68                 .get(xpub);
  69             getRequest.onsuccess = function(e) {
  70                 if(e.target.result) {
  71                     resolve(e.target.result.key);
  72                 } else {
  73                     reject(new Error('not found by XPub'));
  74                 }
  75             };
  76             getRequest.onerror = function() {
  77                 reject(new Error('db get error'));
  78             };
  79         }).catch(error => {
  80             reject(error);
  81         });
  82     });
  83     return retPromise;
  84 };
  85
  86 /**
  87  * List key
  88  *
  89  * @returns {Promise}
  90  */
  91 keysSDK.prototype.list = function() {
  92     let retPromise = new Promise((resolve, reject) => {
  93         getDB().then(db => {
  94             let transaction = db.transaction(['keys'], 'readonly');
  95             let objectStore = transaction.objectStore('keys');
  96             let oc = objectStore.openCursor();
  97             let ret = [];
  98             oc.onsuccess = function (event) {
  99                 var cursor = event.target.result;
 100                 if (cursor) {
 101                     ret.push({alias: cursor.value.alias, xpub: cursor.value.xpub});
 102                     cursor.continue();
 103                 } else {
 104                     resolve(ret);
 105                 }
 106             };
 107             oc.onerror = function(e){
 108                 reject(e);
 109             };
 110         }).catch(err => {
 111             reject(err);
 112         });
 113     });
 114     return retPromise;
 115 };
 116
 117 /**
 118  * Create a new key.
 119  *
 120  * @param {String} alias - User specified, unique identifier.
 121  * @param {String} password - User specified, key password.
 122  */
 123 keysSDK.prototype.create = function(alias, password) {
 124     var normalizedAlias = alias.toLowerCase().trim();
 125     let retPromise = new Promise((resolve, reject) => {
 126         getDB().then(db => {
 127             let getRequest = db.transaction(['keys'], 'readonly')
 128                 .objectStore('keys')
 129                 .index('alias')
 130                 .get(normalizedAlias);
 131             getRequest.onsuccess = function (e) {
 132                 if (e.target.result) {
 133                     reject(new Error('key alias already exists'));
 134                     return;
 135                 }
 136                 let data = {};
 137                 data.alias = normalizedAlias;
 138                 data.auth = password;
 139                 createKey(data).then((res) => {
 140                     let jsonData = JSON.parse(res.data);
 141                     let dbData = {
 142                         key:res.data,
 143                         xpub:jsonData.xpub,
 144                         alias:alias,
 145                     };
 146                     let request = db.transaction(['keys'], 'readwrite')
 147                         .objectStore('keys')
 148                         .add(dbData);
 149                     request.onsuccess = function () {
 150                         resolve({xpub:jsonData.xpub, alias: alias});
 151                     };
 152                     request.onerror = function () {
 153                         reject(new Error('db insert error'));
 154                     };
 155                 }).catch(error => {
 156                     reject(error);
 157                 });
 158             };
 159             getRequest.onerror = function () {
 160                 reject(new Error('db get error'));
 161             };
 162         }).catch(error => {
 163             reject(error);
 164         });
 165     });
 166     return retPromise;
 167 };
 168
 169
 170 /**
 171  * Create a new key.
 172  *
 173  * @param {String} xpub - xpub.
 174  */
 175 keysSDK.prototype.createPubkey = function(xpub) {
 176     let retPromise = new Promise((resolve, reject) => {
 177         let data = {};
 178         data.xpub = xpub;
 179         data.seed = 1;
 180         createPubkey(data).then((res) => {
 181             let jsonData = JSON.parse(res.data);
 182             resolve(jsonData);
 183         }).catch(error => {
 184             reject(error);
 185         });
 186     });
 187     return retPromise;
 188 };
 189
 190 export default keysSDK;