feat: support bytom2 chain

diff --git a/src/models/account.js b/src/models/account.js
index d6bfd3a..0ac2ae9 100644 (file)
--- a/src/models/account.js
+++ b/src/models/account.js
@@ -5,8 +5,48 @@ import _ from 'lodash'
 import {getDomains, camelize} from '@/utils/utils.js'
 import * as Sentry from "@sentry/browser";
 
+import { wallet, setChain, setNet } from './wallet'
+
 let account = {
-  setupNet: bytom.setupNet
+  // setupNet: bytom.setupNet
+  setupNet: (net) => {
+    const network = net.substr(0, 7)
+    const chain = net.substr(7)
+    console.log(network, chain);
+    setChain(chain)
+    setNet(network)
+    // older version
+    bytom.setupNet(net)
+  }
+}
+
+function findOrCreateAccount (pubkey, chain) {
+  const currentChain = wallet.options.chain
+  setChain(chain)
+  // return bytom.wallet.list(pubkey).then(async (wallet) =>{
+  return wallet.getWallets(pubkey).then(async (res) =>{
+    if (res.length > 0) {
+      return {
+        guid: res[0].guid,
+        address: res[0].addresses ? res[0].addresses[0] : res[0].address
+      }
+    } else {
+      // return bytom.accounts.createNewAccount(pubkey, 'byone')
+      return wallet.createAccount(pubkey, 'byone')
+    }
+  }).finally(() => {
+    setChain(currentChain)
+  })
+}
+
+function createAccount (pubkey, chain) {
+  // bytom.setupNet(`${net}${chain}`)
+  // return bytom.accounts.createNewAccount(pubkey, 'byone')
+  const currentChain = wallet.options.chain
+  setChain(chain)
+  return wallet.createAccount(pubkey, 'byone').finally(() => {
+    setChain(currentChain)
+  })
 }
 
 account.createKey = function(accountAlias, keyAlias, passwd, context) {
@@ -25,7 +65,8 @@ account.createKey = function(accountAlias, keyAlias, passwd, context) {
     _bytom.keychain.removeUnverifyIdentity(_bytom.settings.network);
     _bytom.settings.netType = 'bytom';
 
-    const resultObj = bytom.keys.createKey(keyAlias, passwd)
+    // const resultObj = bytom.keys.createKey(keyAlias, passwd)
+    const resultObj = wallet.createKey(keyAlias, passwd)
 
     resultObj.alias = accountAlias
     resultObj.keyAlias = keyAlias
@@ -50,12 +91,15 @@ account.createAccount = function( context) {
   let retPromise = new Promise((resolve, reject) => {
     const _bytom = context.bytom.clone();
     const currentAccount = _bytom.currentAccount
-
     const keystore = currentAccount.keystore
-    bytom.setupNet(`${context.net}bytom`)
-    bytom.accounts.createNewAccount(keystore.xpub, 'byone').then( async (ret) => {
-      let resultObj =  Object.assign(currentAccount, ret)
+
+    Promise.all([
+      createAccount(keystore.xpub, 'bytom'),
+      createAccount(keystore.xpub, 'bytom1')
+    ]).then(async ([bytom2Account, bytom1Account]) => {
+      let resultObj =  Object.assign(currentAccount, bytom2Account)
       resultObj.vMnemonic = true;
+      resultObj.bytom1 = bytom1Account
 
       const domains = await getDomains();
       _bytom.settings.domains = Array.from(new Set(_bytom.settings.domains.concat(domains)))
@@ -82,45 +126,34 @@ account.restoreByMnemonic = function(accountAlias, mnemonic, passwd, context) {
     }
 
     _bytom.keychain.removeUnverifyIdentity(_bytom.settings.network);
-
-    const res = bytom.keys.restoreFromMnemonic(keyAlias, passwd, mnemonic)
-
     _bytom.settings.netType = 'bytom';
 
-    bytom.setupNet(`${context.net}bytom`)
-    bytom.wallet.list(res.xpub).then(async (wallet) =>{
-      let walletInfo
-      if(wallet.length>0){
-        let ret = {
-          guid:wallet[0].guid,
-          address:wallet[0].addresses[0]
-        }
-
-        walletInfo = Promise.resolve(ret)
-      }else{
-        walletInfo = bytom.accounts.createNewAccount(res.xpub, 'byone')
-      }
-
+    // const res = bytom.keys.restoreFromMnemonic(keyAlias, passwd, mnemonic)
+    const res = wallet.restoreFromMnemonic(keyAlias, passwd, mnemonic)
+    
+    Promise.all([
+      findOrCreateAccount(res.xpub, 'bytom'),
+      findOrCreateAccount(res.xpub, 'bytom1'),
+    ]).then(async ([bytom2Account, bytom1Account]) => {
       const domains = await getDomains();
       _bytom.settings.domains = Array.from(new Set(_bytom.settings.domains.concat(domains)))
+      
+      let resultObj =  Object.assign(res, bytom2Account)
+      resultObj.alias = accountAlias
+      resultObj.keyAlias = keyAlias
+      resultObj.vMnemonic = true
+      resultObj.bytom1 = bytom1Account
+
+      _bytom.keychain.pairs[_bytom.settings.network][accountAlias] = resultObj
+      _bytom.currentAccount = resultObj
 
-      walletInfo.then(ret => {
-        let resultObj =  Object.assign(res, ret)
-        resultObj.alias = accountAlias
-        resultObj.keyAlias = keyAlias
-        resultObj.vMnemonic = true
-
-        _bytom.keychain.pairs[_bytom.settings.network][accountAlias] = resultObj
-        _bytom.currentAccount = resultObj
-
-        context[Actions.UPDATE_STORED_BYTOM](_bytom).then(() => {
-          resolve(ret)
-        })
-          .catch(error => {
-            reject(error)
-          })
-
+      context[Actions.UPDATE_STORED_BYTOM](_bytom).then(() => {
+        resolve(bytom2Account)
+      })
+      .catch(error => {
+        reject(error)
       })
+
     })
   })
   return retPromise
@@ -137,91 +170,79 @@ account.restoreByKeystore = function(accountAlias, keystore, password, context)
     }
 
     _bytom.keychain.removeUnverifyIdentity(_bytom.settings.network);
-
-    const res = bytom.keys.restoreFromKeystore(password, keystore)
-
     _bytom.settings.netType = 'bytom';
 
-    bytom.setupNet(`${context.net}bytom`)
-    bytom.wallet.list(res.xpub).then(async (wallet) =>{
-      let walletInfo
-      if(wallet.length>0){
-        let ret = {
-          guid:wallet[0].guid,
-          address:wallet[0].addresses[0]
-        }
-
-        walletInfo = Promise.resolve(ret)
-      }else{
-        walletInfo = bytom.accounts.createNewAccount(res.xpub, 'byone')
-      }
-
+    // const res = bytom.keys.restoreFromKeystore(password, keystore)
+    const res = wallet.restoreFromKeystore(password, keystore)
 
+    Promise.all([
+      findOrCreateAccount(res.xpub, 'bytom'),
+      findOrCreateAccount(res.xpub, 'bytom1'),
+    ]).then(async ([bytom2Account, bytom1Account]) => {
       const domains = await getDomains();
       _bytom.settings.domains = Array.from(new Set(_bytom.settings.domains.concat(domains)))
+      
+      let resultObj =  Object.assign(bytom2Account, {})
+      resultObj.alias = accountAlias
+      resultObj.keyAlias = res.keyAlias
+      resultObj.vMnemonic = true
+      resultObj.keystore = keystore
+      resultObj.xpub = res.xpub
+      resultObj.bytom1 = bytom1Account
+
+      _bytom.keychain.pairs[_bytom.settings.network][accountAlias] = resultObj
+      _bytom.currentAccount = resultObj
 
-      walletInfo.then(ret => {
-        let resultObj =  Object.assign(ret, {})
-        resultObj.alias = accountAlias
-        resultObj.keyAlias = res.keyAlias
-        resultObj.vMnemonic = true
-        resultObj.keystore = keystore
-        resultObj.xpub = res.xpub
-
-        _bytom.keychain.pairs[_bytom.settings.network][accountAlias] = resultObj
-        _bytom.currentAccount = resultObj
-
-        context[Actions.UPDATE_STORED_BYTOM](_bytom).then(() => {
-          resolve(ret)
-        })
-          .catch(error => {
-            reject(error)
-          })
-
+      context[Actions.UPDATE_STORED_BYTOM](_bytom).then(() => {
+        resolve(bytom2Account)
       })
+        .catch(error => {
+          reject(error)
+        })
     })
   })
   return retPromise
 }
 
 account.copy = function(guid) {
-  let retPromise = new Promise((resolve, reject) => {
-    bytom.accounts
-      .copyAccountUseServer(guid, 'btm')
-      .then(ret => {
-        resolve(ret)
-      })
-      .catch(error => {
-        reject(error)
-      })
-  })
-  return retPromise
+  return wallet.copyToVapor(guid, 'btm')
+  // let retPromise = new Promise((resolve, reject) => {
+  //   bytom.accounts
+  //     .copyAccountUseServer(guid, 'btm')
+  //     .then(ret => {
+  //       resolve(ret)
+  //     })
+  //     .catch(error => {
+  //       reject(error)
+  //     })
+  // })
+  // return retPromise
 }
 
-account.listVapor = function(guid) {
-  let retPromise = new Promise((resolve, reject) => {
-    bytom.accounts
-      .listVaporAccountUseServer(guid)
-      .then(ret => {
-        resolve(ret)
-      })
-      .catch(error => {
-        reject(error)
-      })
-  })
-  return retPromise
-}
+// account.listVapor = function(guid) {
+//   let retPromise = new Promise((resolve, reject) => {
+//     bytom.accounts
+//       .listVaporAccountUseServer(guid)
+//       .then(ret => {
+//         resolve(ret)
+//       })
+//       .catch(error => {
+//         reject(error)
+//       })
+//   })
+//   return retPromise
+// }
 
 account.balance = function(address , context) {
   let retPromise = new Promise((resolve, reject) => {
-    bytom.accounts
-      .listAddressUseServer(address)
+    wallet.getBalances(address)
+    // bytom.accounts
+      // .listAddressUseServer(address)
       .then(address => {
         let balances = address.balances || []
         let votes = address.votes || []
         const _bytom = context.bytom.clone();
 
-
         const isVapor = _bytom.settings.netType === 'vapor'
         const _currentBalance = isVapor? _bytom.currentAccount.vpBalances : _bytom.currentAccount.balances
 
@@ -263,21 +284,23 @@ account.balance = function(address , context) {
   return retPromise
 }
 
-account.list = function() {
-  return  bytom.accounts
-      .listAccountUseServer()
-}
+// account.list = function() {
+//   return  bytom.accounts
+//       .listAccountUseServer()
+// }
+
 account.listKeyByXpubOld = function(xpub){
   return  bytom.keys
     .getKeyByXPub(xpub)
 }
 
-account.backup = function() {
-  return bytom.wallet.backup()
-}
+// account.backup = function() {
+//   return bytom.wallet.backup()
+// }
 
 account.isValidMnemonic = function(mnemonic) {
-  return bytom.keys.isValidMnemonic(mnemonic)
+  // return bytom.keys.isValidMnemonic(mnemonic)
+  return wallet.isValidMnemonic(mnemonic)
 }
 
 account.isValidKeystore = function(keystore, context) {
@@ -339,10 +362,10 @@ account.isAliasValid = function(alias, context){
 
 account.decryptMnemonic = function(vault,password, context) {
   const keystore = context.bytom.currentAccount.keystore;
-  return bytom.keys.decryptMnemonic(vault, password, keystore)
+  // return bytom.keys.decryptMnemonic(vault, password, keystore)
+  return wallet.decryptMnemonic(vault, password, keystore)
 }
 
-
 account.createOld = function(accountAlias, keyAlias, passwd, success, error) {
   let retPromise = new Promise((resolve, reject) => {
     if(!keyAlias){
@@ -368,7 +391,8 @@ account.createOld = function(accountAlias, keyAlias, passwd, success, error) {
 }
 
 account.isValidPassword = function(keystore, password){
-  return bytom.keys.verifyPassword(keystore, password)
+  // return bytom.keys.verifyPassword(keystore, password)
+  return wallet.isValidPassword(password, keystore)
 }
 
 export default account