src/sdk/keys.js

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