api/wallet.go

   1 package api
   2
   3 import (
   4         "context"
   5
   6         "github.com/vapor/account"
   7         "github.com/vapor/blockchain/pseudohsm"
   8         "github.com/vapor/crypto/ed25519/chainkd"
   9         "github.com/vapor/errors"
  10 )
  11
  12 // POST /wallet error
  13 func (a *API) walletError() Response {
  14         return NewErrorResponse(errors.New("wallet not found, please check that the wallet is open"))
  15 }
  16
  17 // WalletImage hold the ziped wallet data
  18 type WalletImage struct {
  19         AccountImage *account.Image      `json:"account_image"`
  20         KeyImages    *pseudohsm.KeyImage `json:"key_images"`
  21 }
  22
  23 func (a *API) restoreWalletImage(ctx context.Context, image WalletImage) Response {
  24         if err := a.wallet.Hsm.Restore(image.KeyImages); err != nil {
  25                 return NewErrorResponse(errors.Wrap(err, "restore key images"))
  26         }
  27         if err := a.wallet.AccountMgr.Restore(image.AccountImage); err != nil {
  28                 return NewErrorResponse(errors.Wrap(err, "restore account image"))
  29         }
  30
  31         var allAccounts []*account.Account
  32         for _, acctImage := range image.AccountImage.Slice {
  33                 allAccounts = append(allAccounts, acctImage.Account)
  34         }
  35
  36         if err := a.wallet.RecoveryMgr.AddrResurrect(allAccounts); err != nil {
  37                 return NewErrorResponse(err)
  38         }
  39
  40         a.wallet.RescanBlocks()
  41         return NewSuccessResponse(nil)
  42 }
  43
  44 func (a *API) backupWalletImage() Response {
  45         keyImages, err := a.wallet.Hsm.Backup()
  46         if err != nil {
  47                 return NewErrorResponse(errors.Wrap(err, "backup key images"))
  48         }
  49         accountImage, err := a.wallet.AccountMgr.Backup()
  50         if err != nil {
  51                 return NewErrorResponse(errors.Wrap(err, "backup account image"))
  52         }
  53
  54         image := &WalletImage{
  55                 KeyImages:    keyImages,
  56                 AccountImage: accountImage,
  57         }
  58         return NewSuccessResponse(image)
  59 }
  60
  61 func (a *API) rescanWallet() Response {
  62         allAccounts, err := a.wallet.AccountMgr.ListAccounts("")
  63         if err != nil {
  64                 return NewErrorResponse(err)
  65         }
  66
  67         if err := a.wallet.RecoveryMgr.AddrResurrect(allAccounts); err != nil {
  68                 return NewErrorResponse(err)
  69         }
  70
  71         a.wallet.RescanBlocks()
  72         return NewSuccessResponse(nil)
  73 }
  74
  75 // WalletInfo return wallet information
  76 type WalletInfo struct {
  77         BestBlockHeight uint64 `json:"best_block_height"`
  78         WalletHeight    uint64 `json:"wallet_height"`
  79 }
  80
  81 func (a *API) getWalletInfo() Response {
  82         bestBlockHeight := a.chain.BestBlockHeight()
  83         walletStatus := a.wallet.GetWalletStatusInfo()
  84
  85         return NewSuccessResponse(&WalletInfo{
  86                 BestBlockHeight: bestBlockHeight,
  87                 WalletHeight:    walletStatus.WorkHeight,
  88         })
  89 }
  90
  91 func (a *API) recoveryFromRootXPubs(ctx context.Context, in struct {
  92         XPubs []chainkd.XPub `json:"xpubs"`
  93 }) Response {
  94         if err := a.wallet.RecoveryMgr.AcctResurrect(in.XPubs); err != nil {
  95                 return NewErrorResponse(err)
  96         }
  97
  98         a.wallet.RescanBlocks()
  99         return NewSuccessResponse(nil)
 100 }