"time"
"github.com/vapor/account"
+ acc "github.com/vapor/account"
"github.com/vapor/blockchain/pseudohsm"
"github.com/vapor/blockchain/signers"
"github.com/vapor/blockchain/txbuilder"
return utxo
}
+func AddInput(sourceID bc.Hash, assetID bc.AssetID, amount uint64, pos uint64, controlProgram []byte) *types.TxInput {
+ return types.NewSpendInput(nil, sourceID, assetID, amount, pos, controlProgram)
+}
+
func AddTxOutput(assetID bc.AssetID, amount uint64, controlProgram []byte) *types.TxOutput {
- out := types.NewIntraChainOutput(assetID, amount, controlProgram)
- return out
+ return types.NewIntraChainOutput(assetID, amount, controlProgram)
}
func BuildTx(baseUtxo *account.UTXO, signer *signers.Signer) (*txbuilder.Template, error) {
func CreateTxBuilder(baseUtxo *account.UTXO, signer *signers.Signer) (*txbuilder.TemplateBuilder, error) {
tplBuilder := txbuilder.NewBuilder(time.Now())
+ txInput := AddInput(bc.Hash{V0: 1}, baseUtxo.AssetID, 10000, uint64(1), baseUtxo.ControlProgram)
txOutput := AddTxOutput(baseUtxo.AssetID, 100, baseUtxo.ControlProgram)
+ tplBuilder.AddInput(txInput, &txbuilder.SigningInstruction{Position: 0})
tplBuilder.AddOutput(txOutput)
return tplBuilder, nil
}
defer os.RemoveAll(dirPath)
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
+ walletStore := NewMockWalletStore(testDB)
hsm, err := pseudohsm.New(dirPath)
if err != nil {
t.Fatal(err)
t.Fatal(err)
}
- acctMgr := account.NewManager(testDB, nil)
- recoveryMgr := newRecoveryManager(testDB, acctMgr)
+ acctStore := NewMockAccountStore(testDB)
+ acctMgr := account.NewManager(acctStore, nil)
+ recoveryMgr := NewRecoveryManager(walletStore, acctMgr)
recoveryMgr.state = newRecoveryState()
recoveryMgr.state.XPubs = []chainkd.XPub{xpub.XPub}
recoveryMgr.state.XPubsStatus = newBranchRecoveryState(acctRecoveryWindow)
defer os.RemoveAll(dirPath)
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
+ walletStore := NewMockWalletStore(testDB)
hsm, err := pseudohsm.New(dirPath)
if err != nil {
t.Fatal(err)
t.Fatal(err)
}
- acctMgr := account.NewManager(testDB, nil)
- recoveryMgr := newRecoveryManager(testDB, acctMgr)
+ acctStore := NewMockAccountStore(testDB)
+ acctMgr := account.NewManager(acctStore, nil)
+ recoveryMgr := NewRecoveryManager(walletStore, acctMgr)
acc1 := &account.Account{ID: "testA", Alias: "test1", Signer: &signers.Signer{XPubs: []chainkd.XPub{xpub.XPub}, KeyIndex: 1, DeriveRule: signers.BIP0044}}
acc2 := &account.Account{ID: "testB", Alias: "test2"}
acc3 := &account.Account{ID: "testC", Alias: "test3", Signer: &signers.Signer{XPubs: []chainkd.XPub{xpub.XPub}, KeyIndex: 2, DeriveRule: 3}}
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
recoveryDB := dbm.NewDB("recdb", "leveldb", dirPath)
+ recoveryStore := NewMockWalletStore(recoveryDB)
hsm, err := pseudohsm.New(dirPath)
if err != nil {
t.Fatal(err)
t.Fatal(err)
}
- acctMgr := account.NewManager(testDB, nil)
+ acctStore := NewMockAccountStore(testDB)
+ acctMgr := account.NewManager(acctStore, nil)
txs, err := MockTxsP2PKH(acctMgr, xpub.XPub, false)
- recAcctMgr := account.NewManager(recoveryDB, nil)
- recoveryMgr := newRecoveryManager(recoveryDB, recAcctMgr)
+ recActStore := NewMockAccountStore(recoveryDB)
+ recAcctMgr := account.NewManager(recActStore, nil)
+ recoveryMgr := NewRecoveryManager(recoveryStore, recAcctMgr)
cases := []struct {
xPubs []chainkd.XPub
for _, acct := range Accounts {
tmp, err := recAcctMgr.GetAccountByXPubsIndex(acct.XPubs, acct.KeyIndex)
- if err != nil {
+ if err != nil && err != acc.ErrFindAccount {
t.Fatal("recovery from XPubs err:", err)
}
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
recoveryDB := dbm.NewDB("recdb", "leveldb", dirPath)
+ recoveryStore := NewMockWalletStore(recoveryDB)
hsm, err := pseudohsm.New(dirPath)
if err != nil {
t.Fatal(err)
t.Fatal(err)
}
- acctMgr := account.NewManager(testDB, nil)
+ acctStore := NewMockAccountStore(testDB)
+ acctMgr := account.NewManager(acctStore, nil)
txs, err := MockTxsP2PKH(acctMgr, xpub.XPub, true)
if err != nil {
t.Fatal("recovery by rescan account err:", err)
t.Fatal("recovery by rescan account err:", err)
}
- recAcctMgr := account.NewManager(recoveryDB, nil)
+ recActStore := NewMockAccountStore(recoveryDB)
+ recAcctMgr := account.NewManager(recActStore, nil)
for _, acct := range allAccounts {
if err := recAcctMgr.SaveAccount(acct); err != nil {
t.Fatal("recovery by rescan account err:", err)
}
}
- recoveryMgr := newRecoveryManager(recoveryDB, recAcctMgr)
+ recoveryMgr := NewRecoveryManager(recoveryStore, recAcctMgr)
acct := &account.Account{ID: "testA", Alias: "test1", Signer: &signers.Signer{XPubs: []chainkd.XPub{xpub.XPub}, KeyIndex: 1, DeriveRule: 3}}
for _, acct := range accounts {
tmp, err := recAcctMgr.GetAccountByXPubsIndex(acct.XPubs, acct.KeyIndex)
- if err != nil {
+ if err != nil && err != acc.ErrFindAccount {
t.Fatal("recovery from XPubs err:", err)
}
defer os.RemoveAll(dirPath)
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
+ testStore := NewMockWalletStore(testDB)
hsm, err := pseudohsm.New(dirPath)
if err != nil {
t.Fatal(err)
t.Fatal(err)
}
- acctMgr := account.NewManager(testDB, nil)
- recoveryMgr := newRecoveryManager(testDB, acctMgr)
+ acctStore := NewMockAccountStore(testDB)
+ acctMgr := account.NewManager(acctStore, nil)
+ recoveryMgr := NewRecoveryManager(testStore, acctMgr)
acc1 := &account.Account{ID: "testA", Alias: "test1", Signer: &signers.Signer{XPubs: []chainkd.XPub{xpub1.XPub}, KeyIndex: 1, DeriveRule: signers.BIP0044}}
acc2 := &account.Account{ID: "testB", Alias: "test2", Signer: &signers.Signer{XPubs: []chainkd.XPub{xpub2.XPub}, KeyIndex: 1, DeriveRule: signers.BIP0032}}
acc3 := &account.Account{ID: "testC", Alias: "test3", Signer: &signers.Signer{XPubs: []chainkd.XPub{xpub2.XPub}, KeyIndex: 2, DeriveRule: signers.BIP0044}}
defer os.RemoveAll(dirPath)
testDB := dbm.NewDB("testdb", "leveldb", "temp")
+ testStore := NewMockWalletStore(testDB)
defer os.RemoveAll("temp")
hsm, err := pseudohsm.New(dirPath)
t.Fatal(err)
}
- acctMgr := account.NewManager(testDB, nil)
- recoveryMgr := newRecoveryManager(testDB, acctMgr)
+ acctStore := NewMockAccountStore(testDB)
+ acctMgr := account.NewManager(acctStore, nil)
+ recoveryMgr := NewRecoveryManager(testStore, acctMgr)
// StatusInit init recovery status manager.
recoveryMgr.state = newRecoveryState()
recoveryMgr.state.XPubs = []chainkd.XPub{xpub.XPub}
recoveryMgr.commitStatusInfo()
- recoveryMgrRestore := newRecoveryManager(testDB, acctMgr)
+ recoveryMgrRestore := NewRecoveryManager(testStore, acctMgr)
if err := recoveryMgrRestore.LoadStatusInfo(); err != nil {
t.Fatal("TestLoadStatusInfo err:", err)
}
defer os.RemoveAll(dirPath)
testDB := dbm.NewDB("testdb", "leveldb", "temp")
+ testStore := NewMockWalletStore(testDB)
defer os.RemoveAll("temp")
- acctMgr := account.NewManager(testDB, nil)
- recoveryMgr := newRecoveryManager(testDB, acctMgr)
+ acctStore := NewMockAccountStore(testDB)
+ acctMgr := account.NewManager(acctStore, nil)
+ recoveryMgr := NewRecoveryManager(testStore, acctMgr)
if !recoveryMgr.tryStartXPubsRec() {
t.Fatal("recovery manager try lock test err")
}
}
}
-func bip44ContractIndexKey(accountID string, change bool) []byte {
- contractIndexPrefix := []byte("ContractIndex")
- key := append(contractIndexPrefix, accountID...)
- if change {
- return append(key, []byte{1}...)
- }
- return append(key, []byte{0}...)
-}
-
func TestContractIndexResidue(t *testing.T) {
dirPath, err := ioutil.TempDir(".", "")
if err != nil {
defer os.RemoveAll(dirPath)
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
+ testStore := NewMockWalletStore(testDB)
hsm, err := pseudohsm.New(dirPath)
if err != nil {
t.Fatal(err)
}
contractIndexResidue := uint64(5)
- acctMgr := account.NewManager(testDB, nil)
- recoveryMgr := newRecoveryManager(testDB, acctMgr)
+ acctStore := NewMockAccountStore(testDB)
+ acctMgr := account.NewManager(acctStore, nil)
+ recoveryMgr := NewRecoveryManager(testStore, acctMgr)
acct := &account.Account{ID: "testA", Alias: "test1", Signer: &signers.Signer{XPubs: []chainkd.XPub{xpub1.XPub}, KeyIndex: 1, DeriveRule: signers.BIP0044}}
cp1 := &account.CtrlProgram{AccountID: acct.ID, Address: "address1", KeyIndex: 10, Change: false}
setContractIndexKey := func(acctMgr *account.Manager, accountID string, change bool) {
- testDB.Set(bip44ContractIndexKey(accountID, change), common.Unit64ToBytes(contractIndexResidue))
+ testDB.Set(Bip44ContractIndexKey(accountID, change), common.Unit64ToBytes(contractIndexResidue))
}
delAccount := func(acctMgr *account.Manager, accountID string, change bool) {