Merge pull request #1467 from Bytom/dev

[bytom/bytom.git] / wallet / wallet_test.go

diff --git a/wallet/wallet_test.go b/wallet/wallet_test.go
index 76c8009..1914016 100644 (file)
--- a/wallet/wallet_test.go
+++ b/wallet/wallet_test.go
@@ -1,22 +1,20 @@
 package wallet
 
 import (
-       "context"
        "io/ioutil"
        "os"
        "testing"
        "time"
 
-       "github.com/tendermint/go-wire/data/base58"
        dbm "github.com/tendermint/tmlibs/db"
 
        "github.com/bytom/account"
        "github.com/bytom/asset"
        "github.com/bytom/blockchain/pseudohsm"
+       "github.com/bytom/blockchain/signers"
        "github.com/bytom/blockchain/txbuilder"
        "github.com/bytom/consensus"
        "github.com/bytom/crypto/ed25519/chainkd"
-       "github.com/bytom/crypto/sha3pool"
        "github.com/bytom/database/leveldb"
        "github.com/bytom/protocol"
        "github.com/bytom/protocol/bc"
@@ -34,7 +32,7 @@ func TestWalletUpdate(t *testing.T) {
        defer os.RemoveAll("temp")
 
        store := leveldb.NewStore(testDB)
-       txPool := protocol.NewTxPool()
+       txPool := protocol.NewTxPool(store)
 
        chain, err := protocol.NewChain(store, txPool)
        if err != nil {
@@ -47,17 +45,17 @@ func TestWalletUpdate(t *testing.T) {
                t.Fatal(err)
        }
 
-       xpub1, err := hsm.XCreate("test_pub1", "password")
+       xpub1, _, err := hsm.XCreate("test_pub1", "password", "en")
        if err != nil {
                t.Fatal(err)
        }
 
-       testAccount, err := accountManager.Create(nil, []chainkd.XPub{xpub1.XPub}, 1, "testAccount")
+       testAccount, err := accountManager.Create([]chainkd.XPub{xpub1.XPub}, 1, "testAccount", signers.BIP0044)
        if err != nil {
                t.Fatal(err)
        }
 
-       controlProg, err := accountManager.CreateAddress(nil, testAccount.ID, false)
+       controlProg, err := accountManager.CreateAddress(testAccount.ID, false)
        if err != nil {
                t.Fatal(err)
        }
@@ -65,7 +63,7 @@ func TestWalletUpdate(t *testing.T) {
        controlProg.KeyIndex = 1
 
        reg := asset.NewRegistry(testDB, chain)
-       asset, err := reg.Define([]chainkd.XPub{xpub1.XPub}, 1, nil, "TESTASSET")
+       asset, err := reg.Define([]chainkd.XPub{xpub1.XPub}, 1, nil, "TESTASSET", nil)
        if err != nil {
                t.Fatal(err)
        }
@@ -84,6 +82,7 @@ func TestWalletUpdate(t *testing.T) {
        tx := types.NewTx(*txData)
        block := mockSingleBlock(tx)
        txStatus := bc.NewTransactionStatus()
+       txStatus.SetStatus(0, false)
        store.SaveBlock(block, txStatus)
 
        w := mockWallet(testDB, accountManager, reg, chain)
@@ -92,112 +91,16 @@ func TestWalletUpdate(t *testing.T) {
                t.Fatal(err)
        }
 
-       want, err := w.GetTransactionsByTxID(tx.ID.String())
-       if len(want) != 1 {
+       if _, err := w.GetTransactionByTxID(tx.ID.String()); err != nil {
                t.Fatal(err)
        }
 
-       wants, err := w.GetTransactionsByTxID("")
+       wants, err := w.GetTransactions("")
        if len(wants) != 1 {
                t.Fatal(err)
        }
 }
 
-func TestExportAndImportPrivKey(t *testing.T) {
-       dirPath, err := ioutil.TempDir(".", "")
-       if err != nil {
-               t.Fatal(err)
-       }
-       defer os.RemoveAll(dirPath)
-
-       testDB := dbm.NewDB("testdb", "leveldb", "temp")
-       defer os.RemoveAll("temp")
-
-       store := leveldb.NewStore(testDB)
-       txPool := protocol.NewTxPool()
-
-       chain, err := protocol.NewChain(store, txPool)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       acntManager := account.NewManager(testDB, chain)
-       reg := asset.NewRegistry(testDB, chain)
-
-       hsm, err := pseudohsm.New(dirPath)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       pwd := "password"
-       xpub, err := hsm.XCreate("alias", pwd)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       w, err := NewWallet(testDB, acntManager, reg, hsm, chain)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       ctx := context.Background()
-       acnt1, err := w.AccountMgr.Create(ctx, []chainkd.XPub{xpub.XPub}, 1, "account-alias")
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       priv, err := w.ExportAccountPrivKey(xpub.XPub, pwd)
-
-       wantPriv, err := hsm.LoadChainKDKey(xpub.XPub, pwd)
-       if err != nil {
-               t.Fatal(err)
-       }
-       var hashed [32]byte
-       sha3pool.Sum256(hashed[:], wantPriv[:])
-
-       tmp := append(wantPriv[:], hashed[:4]...)
-       res := base58.Encode(tmp)
-
-       if res != *priv {
-               t.Fatalf("XPrivs should be identical.\nBefore: %v\n After: %v\n", *priv, res)
-       }
-
-       rawPriv, err := base58.Decode(*priv)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       if len(rawPriv) != 68 {
-               t.Fatal("invalid private key hash length")
-       }
-
-       var xprv [64]byte
-       copy(xprv[:], rawPriv[:64])
-
-       _, err = w.ImportAccountPrivKey(xprv, xpub.Alias, pwd, 0, acnt1.Alias)
-       if err != pseudohsm.ErrDuplicateKeyAlias {
-               t.Fatal(err)
-       }
-
-       hsm.XDelete(xpub.XPub, pwd)
-
-       _, err = w.ImportAccountPrivKey(xprv, xpub.Alias, pwd, 0, acnt1.Alias)
-       if err != account.ErrDuplicateAlias {
-               t.Fatal(err)
-       }
-
-       w.AccountMgr.DeleteAccount(acnt1.Alias)
-
-       acnt2, err := w.ImportAccountPrivKey(xprv, xpub.Alias, pwd, 0, acnt1.Alias)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       if acnt2.XPub != acnt1.XPubs[0] {
-               t.Fatalf("XPubs should be identical.\nBefore: %v\n After: %v\n", acnt1.XPubs[0], acnt2.XPub)
-       }
-}
-
 func mockUTXO(controlProg *account.CtrlProgram, assetID *bc.AssetID) *account.UTXO {
        utxo := &account.UTXO{}
        utxo.OutputID = bc.Hash{V0: 1}
@@ -235,14 +138,14 @@ func mockTxData(utxos []*account.UTXO, testAccount *account.Account) (*txbuilder
 }
 
 func mockWallet(walletDB dbm.DB, account *account.Manager, asset *asset.Registry, chain *protocol.Chain) *Wallet {
-       return &Wallet{
-               DB:                  walletDB,
-               AccountMgr:          account,
-               AssetReg:            asset,
-               chain:               chain,
-               rescanProgress:      make(chan struct{}, 1),
-               selfProgramsOnChain: NewSet(),
-       }
+       wallet := &Wallet{
+               DB:          walletDB,
+               AccountMgr:  account,
+               AssetReg:    asset,
+               chain:       chain,
+               RecoveryMgr: newRecoveryManager(walletDB, account),
+       }
+       return wallet
 }
 
 func mockSingleBlock(tx *types.Tx) *types.Block {