src/sdk/accounts.js

   1 import {getDB} from '../db/db';
   2 import {createAccount, createAccountReceiver, signTransaction} from '../wasm/func';
   3 import {handleApiError, handleAxiosError} from '../utils/http';
   4
   5
   6 function accountsSDK(bytom){
   7     this.http = bytom.serverHttp;
   8     this.bytom = bytom;
   9 }
  10
  11 /**
  12  * List of the account.
  13  *
  14  * @returns {Promise} List of Accounts
  15  */
  16 accountsSDK.prototype.listAccountUseServer = function() {
  17     let net = this.bytom.net;
  18     let retPromise = new Promise((resolve, reject) => {
  19         getDB().then(db => {
  20             let transaction = db.transaction(['accounts-server'], 'readonly');
  21             let objectStore = transaction.objectStore('accounts-server').index('net');
  22             let keyRange = IDBKeyRange.only(net);
  23             let oc = objectStore.openCursor(keyRange);
  24             let ret = [];
  25
  26             oc.onsuccess = function (event) {
  27                 var cursor = event.target.result;
  28                 if (cursor) {
  29                     ret.push(cursor.value);
  30                     cursor.continue();
  31                 } else {
  32                     resolve(ret);
  33                 }
  34             };
  35             oc.onerror = function(e){
  36                 reject(e);
  37             };
  38         }).catch(error => {
  39             reject(error);
  40         });
  41     });
  42     return retPromise;
  43 };
  44
  45
  46 /**
  47  * List all addresses and the corresponding balances of a wallet.
  48  *
  49  * @see https://gist.github.com/HAOYUatHZ/0c7446b8f33e7cddd590256b3824b08f#apiv1btmaccountlist-addresses
  50  * @param {String} guid
  51  * @returns {Promise} list of all addresses
  52  */
  53 accountsSDK.prototype.listAddressUseServer = function(address) {
  54     let net = this.bytom.net;
  55     return this.http.request(`account/address?address=${address}`, '', net, 'GET');
  56 };
  57 /**
  58  * Create a new address for a wallet.
  59  *
  60  * @see https://gist.github.com/HAOYUatHZ/0c7446b8f33e7cddd590256b3824b08f#apiv1btmaccountnew-address
  61  * @param {String} guid unique id for each wallet
  62  * @param {String} label alias for the address to be created
  63  * @returns {Promise}
  64  */
  65 accountsSDK.prototype.createAccountReceiverUseServer = function(guid, label) {
  66     let net = this.bytom.net;
  67     let retPromise = new Promise((resolve, reject) => {
  68         let pm = {guid: guid};
  69         if (label) {
  70             pm.label = label;
  71         }
  72         this.http.request('account/new-address', pm, net).then(resp => {
  73             let dbData = resp;
  74             dbData.guid = guid;
  75             dbData.net = net;
  76             getDB().then(db => {
  77                 let transaction = db.transaction(['addresses-server'], 'readwrite');
  78                 let objectStore = transaction.objectStore('addresses-server');
  79                 delete dbData.rootXPub;
  80                 let request = objectStore.add(dbData);
  81                 request.onsuccess = function() {
  82                     resolve(dbData);
  83                 };
  84                 request.onerror = function() {
  85                     reject(request.error);
  86                 };
  87             });
  88         }).catch(error => {
  89             reject(handleAxiosError(error));
  90         });
  91     });
  92     return retPromise;
  93 };
  94
  95 /**
  96  * Create a wallet using a public key. Each wallet is identified by a guid. (by server)
  97  *
  98  * @see https://gist.github.com/HAOYUatHZ/0c7446b8f33e7cddd590256b3824b08f#endpoints
  99  * @param {String} rootXPub
 100  * @param {String} alias alias for the account
 101  * @param {String} label alias for the first address
 102  * @returns {Promise}
 103  */
 104 accountsSDK.prototype.createNewAccount = function(rootXPub, label) {
 105     let net = this.bytom.net;
 106     let pm = {pubkey: rootXPub};
 107     if (label) {
 108         pm.label = label;
 109     }
 110     return this.http.request('account/create', pm, net);
 111 };
 112
 113
 114 /**
 115  * Create a wallet using a public key. Each wallet is identified by a guid. (by server)
 116  *
 117  * @see https://gist.github.com/HAOYUatHZ/0c7446b8f33e7cddd590256b3824b08f#endpoints
 118  * @param {String} rootXPub
 119  * @param {String} alias alias for the account
 120  * @param {String} label alias for the first address
 121  * @returns {Promise}
 122  */
 123 accountsSDK.prototype.createAccountUseServer = function(rootXPub, alias, label) {
 124     let net = this.bytom.net;
 125     let that = this;
 126     let retPromise = new Promise((resolve, reject) => {
 127         getDB().then(db => {
 128             let getRequest = db.transaction(['accounts-server'], 'readonly')
 129                 .objectStore('accounts-server')
 130                 .index('alias')
 131                 .get(alias);
 132             getRequest.onsuccess = function(e) {
 133                 if (e.target.result) {
 134                     reject(new Error('duplicate account alias'));
 135                     return;
 136                 }
 137                 let pm = {pubkey: rootXPub};
 138                 if (label) {
 139                     pm.label = label;
 140                 }
 141                 that.http.request('account/create', pm, net).then(resp => {
 142                     let dbData = resp;
 143                     dbData.rootXPub = rootXPub;
 144                     dbData.alias = alias;
 145                     dbData.net = net;
 146                     getDB().then(db => {
 147                         let transaction = db.transaction(['accounts-server'], 'readwrite');
 148                         let objectStore = transaction.objectStore('accounts-server');
 149                         let request = objectStore.add(dbData);
 150                         request.onsuccess = function() {
 151                             let transaction = db.transaction(['addresses-server'], 'readwrite');
 152                             let objectStore = transaction.objectStore('addresses-server');
 153                             delete dbData.rootXPub;
 154                             let request = objectStore.add(dbData);
 155                             request.onsuccess = function() {
 156                                 resolve(dbData);
 157                             };
 158                             request.onerror = function() {
 159                                 reject(request.error);
 160                             };
 161                         };
 162                         request.onerror = function() {
 163                             reject(request.error);
 164                         };
 165                     });
 166                 }).catch(error => {
 167                     reject(handleAxiosError(error));
 168                 });
 169             };
 170             getRequest.onerror = function() {
 171                 reject(getRequest.error);
 172             };
 173         }).catch(err => {
 174             reject(err);
 175         });
 176     });
 177     return retPromise;
 178 };
 179
 180 /**
 181  * Create a wallet using a public key. Each wallet is identified by a guid. (by server)
 182  *
 183  * @param {String} guid
 184  * @param {String} coin type of coin
 185  * @returns {Promise}
 186  */
 187 accountsSDK.prototype.copyAccountUseServer = function(guid, coin) {
 188     let net = this.bytom.net;
 189     let that = this;
 190     let retPromise = new Promise((resolve, reject) => {
 191         let pm = {guid};
 192         if (coin) {
 193             pm.coin = coin;
 194         }
 195
 196         that.http.request('account/copy', pm, net).then(resp => {
 197             getDB().then(db => {
 198                 let objectStore = db.transaction(['accounts-server'], 'readwrite').objectStore('accounts-server');
 199                 let index = objectStore.index('guid');
 200                 let keyRange = IDBKeyRange.only(guid);
 201                 let getRequest = index.openCursor(keyRange);
 202
 203                 getRequest.onsuccess = function(e) {
 204                     const cursor = e.target.result;
 205                     if(cursor){
 206                         const accountObject = cursor.value;
 207
 208                         accountObject.vpAddress = resp.address;
 209                         const request = cursor.update(accountObject);
 210                         request.onsuccess = function () {
 211                             resolve(accountObject);
 212                         };
 213                         request.onerror = function () {
 214                             reject(request.error);
 215                         };
 216                     }
 217                 };
 218                 getRequest.onerror = function() {
 219                     reject(getRequest.error);
 220                 };
 221             }).catch(err => {
 222                 throw (err);
 223             });
 224         }).catch(err => {
 225             reject(err);
 226         });
 227     });
 228     return retPromise;
 229 };
 230
 231 /**
 232  * list a wallet using a guid. Each wallet is identified by a guid. (by server)
 233  *
 234  * @param {String} guid
 235  * @param {String} coin type of coin
 236  * @returns {Promise}
 237  */
 238 accountsSDK.prototype.listVaporAccountUseServer = function(guid) {
 239     let net = this.bytom.net;
 240     let that = this;
 241     let retPromise = new Promise((resolve, reject) => {
 242         that.http.request('account/addresses', {address:address}, net).then(resp => {
 243             getDB().then(db => {
 244                 let objectStore = db.transaction(['accounts-server'], 'readwrite').objectStore('accounts-server');
 245                 let index = objectStore.index('guid');
 246                 let keyRange = IDBKeyRange.only(guid);
 247                 let getRequest = index.openCursor(keyRange);
 248
 249                 getRequest.onsuccess = function(e) {
 250                     const cursor = e.target.result;
 251                     if(cursor){
 252                         const accountObject = cursor.value;
 253
 254                         accountObject.vpAddress = resp[0].address;
 255                         const request = cursor.update(accountObject);
 256                         request.onsuccess = function () {
 257                             resolve(accountObject);
 258                         };
 259                         request.onerror = function () {
 260                             reject(request.error);
 261                         };
 262                     }
 263                 };
 264                 getRequest.onerror = function() {
 265                     reject(getRequest.error);
 266                 };
 267             }).catch(err => {
 268                 throw (err);
 269             });
 270         }).catch(err => {
 271             reject(err);
 272         });
 273     });
 274     return retPromise;
 275 };
 276
 277 /**
 278  * create account
 279  *
 280  * @param {String} alias
 281  * @param {Int} quorum
 282  * @param {String} rootXPub
 283  * @returns {Promise}
 284  */
 285 accountsSDK.prototype.createAccount = function(alias, quorum, rootXPub) {
 286     let retPromise = new Promise((resolve, reject) => {
 287         getDB().then(db => {
 288             let transaction = db.transaction(['accounts'], 'readwrite');
 289             let objectStore = transaction.objectStore('accounts');
 290             let request = objectStore.add({
 291                 alias:alias,
 292             });
 293             request.onsuccess = function () {
 294                 let data = {alias:alias, quorum:quorum, rootXPub:rootXPub, nextIndex:request.result};
 295                 createAccount(data).then(res => {
 296                     let jsonData = JSON.parse(res.data);
 297                     let putTransaction = db.transaction(['accounts'], 'readwrite');
 298                     let putObjectStore = putTransaction.objectStore('accounts');
 299                     let putRequest = putObjectStore.put(jsonData, request.result);
 300                     putRequest.onsuccess = function() {
 301                         resolve(jsonData);
 302                     };
 303                     putRequest.onerror = function() {
 304                         reject(putRequest.error);
 305                     };
 306                 }).catch(error => {
 307                     reject(error);
 308                 });
 309             };
 310             request.onerror = function() {
 311                 reject(request.error);
 312             };
 313         }).catch(error => {
 314             reject(error);
 315         });
 316     });
 317     return retPromise;
 318 };
 319
 320 /**
 321  * create account address
 322  *
 323  * @param {Object} account createAccount return account Object val
 324  * @param {Int} nextIndex
 325  * @returns {Promise}
 326  */
 327 accountsSDK.prototype.createAccountReceiver = function(account) {
 328     let retPromise = new Promise((resolve, reject) => {
 329         getDB().then(db => {
 330             let transaction = db.transaction(['addresses'], 'readwrite');
 331             let objectStore = transaction.objectStore('addresses');
 332             let request = objectStore.add({
 333                 account_id:account.id,
 334                 account_alias:account.alias,
 335             });
 336             request.onsuccess = function() {
 337                 let data = {account:JSON.stringify(account), nextIndex: request.result};
 338                 createAccountReceiver(data).then(res => {
 339                     let jsonData = JSON.parse(res.data);
 340                     let jsonDB = JSON.parse(res.db);
 341                     let putTransaction = db.transaction(['addresses'], 'readwrite');
 342                     let putObjectStore = putTransaction.objectStore('addresses');
 343                     let putRequest = null;
 344                     for (let key in jsonDB) {
 345                         if(!jsonDB.hasOwnProperty(key)) continue;
 346                         let putData = JSON.parse(jsonDB[key]);
 347                         putRequest = putObjectStore.put(putData, request.result);
 348                     }
 349                     putRequest.onsuccess = function() {
 350                         resolve(jsonData);
 351                     };
 352                     putRequest.onerror = function() {
 353                         reject(putRequest.error);
 354                     };
 355                 }).catch(error => {
 356                     reject(error);
 357                 });
 358             };
 359             request.onerror = function() {
 360                 reject(request.error);
 361             };
 362         }).catch(error => {
 363             reject(error);
 364         });
 365     });
 366     return retPromise;
 367 };
 368
 369 /**
 370  * create account address
 371  *
 372  * @param {Object} account createAccount return account Object val
 373  * @param {Int} nextIndex
 374  * @returns {Promise}
 375  */
 376 accountsSDK.prototype.getAccountXpubById = function(guid) {
 377     let retPromise = new Promise((resolve, reject) => {
 378         getDB().then(db => {
 379             let getRequest = db.transaction(['accounts-server'], 'readonly')
 380                 .objectStore('accounts-server')
 381                 .index('guid')
 382                 .get(guid);
 383             getRequest.onsuccess = function(e) {
 384                 if (!e.target.result) {
 385                     reject(new Error('not found guid'));
 386                     return;
 387                 }
 388                 resolve(e.target.result.rootXPub);
 389             };
 390             getRequest.onerror = function() {
 391                 reject(getRequest.error);
 392             };
 393         }).catch(error => {
 394             reject(error);
 395         });
 396     });
 397     return retPromise;
 398 };
 399
 400
 401 /**
 402  * create account address
 403  *
 404  * @param {Object} account createAccount return account Object val
 405  * @param {Int} nextIndex
 406  * @returns {Promise}
 407  */
 408 accountsSDK.prototype.getAccountXpubByAddress = function(guid) {
 409     let retPromise = new Promise((resolve, reject) => {
 410         getDB().then(db => {
 411             let getRequest = db.transaction(['accounts-server'], 'readonly')
 412                 .objectStore('accounts-server')
 413                 .index('guid')
 414                 .get(guid);
 415             getRequest.onsuccess = function(e) {
 416                 if (!e.target.result) {
 417                     reject(new Error('not found guid'));
 418                     return;
 419                 }
 420                 resolve(e.target.result.rootXPub);
 421             };
 422             getRequest.onerror = function() {
 423                 reject(getRequest.error);
 424             };
 425         }).catch(error => {
 426             reject(error);
 427         });
 428     });
 429     return retPromise;
 430 };
 431
 432 export default accountsSDK;