Introduce new transaction store.

This change replaces the old transaction store file format and
implementation.  The most important change is how the full backing
transactions for any received or sent transaction are now saved,
rather than simply saving parsed-out details of the tx (tx shas, block
height/hash, pkScripts, etc.).

To support the change, notifications for received transaction outputs
and txs spending watched outpoints have been updated to use the new
redeemingtx and recvtx notifications as these contain the full tx,
which is deserializead and inserted into the store.

The old transaction store serialization code is completely removed, as
updating to the new format automatically cannot be done.  Old wallets
first running past this change will error reading the file and start a
full rescan to rebuild the data.  Unlike previous rescan code,
transactions spending outpoint managed by wallet are also included.
This results in recovering not just received history, but history for
sent transactions as well.

account.go

@@ -19,11 +19,12 @@ package main
 import (
 	"bytes"
 	"encoding/base64"
+	"encoding/hex"
 	"fmt"
+	"github.com/conformal/btcscript"
 	"github.com/conformal/btcutil"
 	"github.com/conformal/btcwallet/tx"
 	"github.com/conformal/btcwallet/wallet"
-	"github.com/conformal/btcwire"
 	"path/filepath"
 	"sync"
 )
@@ -67,8 +68,7 @@ type Account struct {
 	name       string
 	fullRescan bool
 	*wallet.Wallet
-	tx.UtxoStore
+	TxStore *tx.Store
-	tx.TxStore
 }
 
 // Lock locks the underlying wallet for an account.
@@ -102,19 +102,31 @@ func (a *Account) Unlock(passphrase []byte) error {
 // there are any transactions with outputs to this address in the blockchain or
 // the btcd mempool.
 func (a *Account) AddressUsed(addr btcutil.Address) bool {
-	// This can be optimized by recording this data as it is read when
+	// This not only can be optimized by recording this data as it is
-	// opening an account, and keeping it up to date each time a new
+	// read when opening an account, and keeping it up to date each time a
-	// received tx arrives.
+	// new received tx arrives, but it probably should in case an address is
+	// used in a tx (made public) but the tx is eventually removed from the
+	// store (consider a chain reorg).
 
 	pkHash := addr.ScriptAddress()
 
-	for i := range a.TxStore {
+	for _, record := range a.TxStore.SortedRecords() {
-		rtx, ok := a.TxStore[i].(*tx.RecvTx)
+		txout, ok := record.(*tx.RecvTxOut)
 		if !ok {
 			continue
 		}
 
-		if bytes.Equal(rtx.ReceiverHash, pkHash) {
+		// Extract address from pkScript.  We currently only care
+		// about P2PKH addresses.
+		sc, addrs, _, err := txout.Addresses(cfg.Net())
+		switch {
+		case err != nil:
+			continue
+		case sc != btcscript.PubKeyHashTy:
+			continue
+		}
+
+		if bytes.Equal(addrs[0].ScriptAddress(), pkHash) {
 			return true
 		}
 	}
@@ -136,14 +148,7 @@ func (a *Account) CalculateBalance(confirms int) float64 {
 		return 0.
 	}
 
-	var bal uint64 // Measured in satoshi
+	bal := a.TxStore.Balance(confirms, bs.Height)
-	for _, u := range a.UtxoStore {
-		// Utxos not yet in blocks (height -1) should only be
-		// added if confirmations is 0.
-		if confirmed(confirms, u.Height, bs.Height) {
-			bal += u.Amt
-		}
-	}
 	return float64(bal) / float64(btcutil.SatoshiPerBitcoin)
 }
 
@@ -162,13 +167,21 @@ func (a *Account) CalculateAddressBalance(addr *btcutil.AddressPubKeyHash, confi
 		return 0.
 	}
 
-	var bal uint64 // Measured in satoshi
+	var bal int64 // Measured in satoshi
-	for _, u := range a.UtxoStore {
+	for _, txout := range a.TxStore.UnspentOutputs() {
 		// Utxos not yet in blocks (height -1) should only be
 		// added if confirmations is 0.
-		if confirmed(confirms, u.Height, bs.Height) {
+		if confirmed(confirms, txout.Height(), bs.Height) {
-			if bytes.Equal(addr.ScriptAddress(), u.AddrHash[:]) {
+			_, addrs, _, _ := txout.Addresses(cfg.Net())
-				bal += u.Amt
+			if len(addrs) != 1 {
+				continue
+			}
+			apkh, ok := addrs[0].(*btcutil.AddressPubKeyHash)
+			if !ok {
+				continue
+			}
+			if *addr == *apkh {
+				bal += txout.Value()
 			}
 		}
 	}
@@ -196,14 +209,14 @@ func (a *Account) CurrentAddress() (btcutil.Address, error) {
 // replies.
 func (a *Account) ListSinceBlock(since, curBlockHeight int32, minconf int) ([]map[string]interface{}, error) {
 	var txInfoList []map[string]interface{}
-	for _, tx := range a.TxStore {
+	for _, txRecord := range a.TxStore.SortedRecords() {
 		// check block number.
-		if since != -1 && tx.GetBlockHeight() <= since {
+		if since != -1 && txRecord.Height() <= since {
 			continue
 		}
 
 		txInfoList = append(txInfoList,
-			tx.TxInfo(a.name, curBlockHeight, a.Net())...)
+			txRecord.TxInfo(a.name, curBlockHeight, a.Net())...)
 	}
 
 	return txInfoList, nil
@@ -222,11 +235,12 @@ func (a *Account) ListTransactions(from, count int) ([]map[string]interface{}, e
 
 	var txInfoList []map[string]interface{}
 
-	lastLookupIdx := len(a.TxStore) - count
+	records := a.TxStore.SortedRecords()
+	lastLookupIdx := len(records) - count
 	// Search in reverse order: lookup most recently-added first.
-	for i := len(a.TxStore) - 1; i >= from && i >= lastLookupIdx; i-- {
+	for i := len(records) - 1; i >= from && i >= lastLookupIdx; i-- {
 		txInfoList = append(txInfoList,
-			a.TxStore[i].TxInfo(a.name, bs.Height, a.Net())...)
+			records[i].TxInfo(a.name, bs.Height, a.Net())...)
 	}
 
 	return txInfoList, nil
@@ -246,13 +260,22 @@ func (a *Account) ListAddressTransactions(pkHashes map[string]struct{}) (
 	}
 
 	var txInfoList []map[string]interface{}
-	for i := range a.TxStore {
+	for _, txRecord := range a.TxStore.SortedRecords() {
-		rtx, ok := a.TxStore[i].(*tx.RecvTx)
+		txout, ok := txRecord.(*tx.RecvTxOut)
 		if !ok {
 			continue
 		}
-		if _, ok := pkHashes[string(rtx.ReceiverHash[:])]; ok {
+		_, addrs, _, _ := txout.Addresses(cfg.Net())
-			info := rtx.TxInfo(a.name, bs.Height, a.Net())
+		if len(addrs) != 1 {
+			continue
+		}
+		apkh, ok := addrs[0].(*btcutil.AddressPubKeyHash)
+		if !ok {
+			continue
+		}
+
+		if _, ok := pkHashes[string(apkh.ScriptAddress())]; ok {
+			info := txout.TxInfo(a.name, bs.Height, a.Net())
 			txInfoList = append(txInfoList, info...)
 		}
 	}
@@ -272,10 +295,11 @@ func (a *Account) ListAllTransactions() ([]map[string]interface{}, error) {
 	}
 
 	// Search in reverse order: lookup most recently-added first.
+	records := a.TxStore.SortedRecords()
 	var txInfoList []map[string]interface{}
-	for i := len(a.TxStore) - 1; i >= 0; i-- {
+	for i := len(records) - 1; i >= 0; i-- {
-		txInfoList = append(txInfoList,
+		info := records[i].TxInfo(a.name, bs.Height, a.Net())
-			a.TxStore[i].TxInfo(a.name, bs.Height, a.Net())...)
+		txInfoList = append(txInfoList, info...)
 	}
 
 	return txInfoList, nil
@@ -394,13 +418,6 @@ func (a *Account) exportBase64() (map[string]string, error) {
 	m["tx"] = base64.StdEncoding.EncodeToString(buf.Bytes())
 	buf.Reset()
 
-	_, err = a.UtxoStore.WriteTo(buf)
-	if err != nil {
-		return nil, err
-	}
-	m["utxo"] = base64.StdEncoding.EncodeToString(buf.Bytes())
-	buf.Reset()
-
 	return m, nil
 }
 
@@ -422,8 +439,8 @@ func (a *Account) Track() {
 		log.Error("Unable to request transaction updates for address.")
 	}
 
-	for _, utxo := range a.UtxoStore {
+	for _, txout := range a.TxStore.UnspentOutputs() {
-		ReqSpentUtxoNtfn(utxo)
+		ReqSpentUtxoNtfn(txout)
 	}
 }
 
@@ -458,6 +475,23 @@ func (a *Account) RescanActiveAddresses() {
 	AcctMgr.ds.FlushAccount(a)
 }
 
+func (a *Account) ResendUnminedTxs() {
+	txs := a.TxStore.UnminedSignedTxs()
+	txbuf := new(bytes.Buffer)
+	for _, tx_ := range txs {
+		tx_.MsgTx().Serialize(txbuf)
+		hextx := hex.EncodeToString(txbuf.Bytes())
+		txsha, err := SendRawTransaction(CurrentServerConn(), hextx)
+		if err != nil {
+			// TODO(jrick): Check error for if this tx is a double spend,
+			// remove it if so.
+		} else {
+			log.Debugf("Resent unmined transaction %v", txsha)
+		}
+		txbuf.Reset()
+	}
+}
+
 // SortedActivePaymentAddresses returns a slice of all active payment
 // addresses in an account.
 func (a *Account) SortedActivePaymentAddresses() []string {
@@ -592,11 +626,12 @@ func (a *Account) ReqNewTxsForAddress(addr btcutil.Address) {
 
 // ReqSpentUtxoNtfn sends a message to btcd to request updates for when
 // a stored UTXO has been spent.
-func ReqSpentUtxoNtfn(u *tx.Utxo) {
+func ReqSpentUtxoNtfn(t *tx.RecvTxOut) {
+	op := t.OutPoint()
 	log.Debugf("Requesting spent UTXO notifications for Outpoint hash %s index %d",
-		u.Out.Hash, u.Out.Index)
+		op.Hash, op.Index)
 
-	NotifySpent(CurrentServerConn(), (*btcwire.OutPoint)(&u.Out))
+	NotifySpent(CurrentServerConn(), op)
 }
 
 // TotalReceived iterates through an account's transaction history, returning the
@@ -609,28 +644,20 @@ func (a *Account) TotalReceived(confirms int) (float64, error) {
 	}
 
 	var totalSatoshis int64
-	for _, e := range a.TxStore {
+	for _, record := range a.TxStore.SortedRecords() {
-		recvtx, ok := e.(*tx.RecvTx)
+		txout, ok := record.(*tx.RecvTxOut)
 		if !ok {
 			continue
 		}
 
 		// Ignore change.
-		addr, err := btcutil.NewAddressPubKeyHash(recvtx.ReceiverHash, cfg.Net())
+		if txout.Change() {
-		if err != nil {
-			continue
-		}
-		info, err := a.Wallet.AddressInfo(addr)
-		if err != nil {
-			continue
-		}
-		if info.Change {
 			continue
 		}
 
 		// Tally if the appropiate number of block confirmations have passed.
-		if confirmed(confirms, recvtx.GetBlockHeight(), bs.Height) {
+		if confirmed(confirms, txout.Height(), bs.Height) {
-			totalSatoshis += recvtx.Amount
+			totalSatoshis += txout.Value()
 		}
 	}
 

acctmgr.go

@@ -17,7 +17,6 @@
 package main
 
 import (
-	"bytes"
 	"container/list"
 	"errors"
 	"fmt"
@@ -187,7 +186,6 @@ func (am *AccountManager) RegisterNewAccount(a *Account) error {
 	// Ensure that the new account is written out to disk.
 	am.ds.ScheduleWalletWrite(a)
 	am.ds.ScheduleTxStoreWrite(a)
-	am.ds.ScheduleUtxoStoreWrite(a)
 	if err := am.ds.FlushAccount(a); err != nil {
 		am.RemoveAccount(a)
 		return err
@@ -198,17 +196,11 @@ func (am *AccountManager) RegisterNewAccount(a *Account) error {
 // Rollback rolls back each managed Account to the state before the block
 // specified by height and hash was connected to the main chain.
 func (am *AccountManager) Rollback(height int32, hash *btcwire.ShaHash) {
-	log.Debugf("Rolling back tx history since block height %v hash %v",
+	log.Debugf("Rolling back tx history since block height %v", height)
-		height, hash)
 
 	for _, a := range am.AllAccounts() {
-		if a.UtxoStore.Rollback(height, hash) {
+		a.TxStore.Rollback(height)
-			am.ds.ScheduleUtxoStoreWrite(a)
+		am.ds.ScheduleTxStoreWrite(a)
-		}
-
-		if a.TxStore.Rollback(height, hash) {
-			am.ds.ScheduleTxStoreWrite(a)
-		}
 	}
 }
 
@@ -247,32 +239,15 @@ func (am *AccountManager) BlockNotify(bs *wallet.BlockStamp) {
 // the transaction IDs match, the record in the TxStore is updated with
 // the full information about the newly-mined tx, and the TxStore is
 // scheduled to be written to disk..
-func (am *AccountManager) RecordMinedTx(txid *btcwire.ShaHash,
+func (am *AccountManager) RecordSpendingTx(tx_ *btcutil.Tx, block *tx.BlockDetails) {
-	blkhash *btcwire.ShaHash, blkheight int32, blkindex int,
-	blktime int64) error {
-
 	for _, a := range am.AllAccounts() {
-		// Search in reverse order.  Since more recently-created
+		// TODO(jrick) this is WRONG -- should not be adding it
-		// transactions are appended to the end of the store, it's
+		// for each account.  Fix before multiple account support
-		// more likely to find it when searching from the end.
+		// actually works.  Maybe a single txstore for all accounts
-		for i := len(a.TxStore) - 1; i >= 0; i-- {
+		// isn't a half bad idea.
-			sendtx, ok := a.TxStore[i].(*tx.SendTx)
+		a.TxStore.InsertSignedTx(tx_, block)
-			if ok {
+		am.ds.ScheduleTxStoreWrite(a)
-				if bytes.Equal(txid.Bytes(), sendtx.TxID[:]) {
-					copy(sendtx.BlockHash[:], blkhash.Bytes())
-					sendtx.BlockHeight = blkheight
-					sendtx.BlockIndex = int32(blkindex)
-					sendtx.BlockTime = blktime
-
-					am.ds.ScheduleTxStoreWrite(a)
-
-					return nil
-				}
-			}
-		}
 	}
-
-	return errors.New("txid does not match any recorded sent transaction")
 }
 
 // CalculateBalance returns the balance, calculated using minconf block
@@ -468,28 +443,29 @@ func (am *AccountManager) ListSinceBlock(since, curBlockHeight int32, minconf in
 }
 
 // accountTx represents an account/transaction pair to be used by
-// GetTransaction().
+// GetTransaction.
 type accountTx struct {
 	Account string
-	Tx      tx.Tx
+	Tx      tx.Record
 }
 
 // GetTransaction returns an array of accountTx to fully represent the effect of
 // a transaction on locally known wallets. If we know nothing about a
 // transaction an empty array will be returned.
-func (am *AccountManager) GetTransaction(txid string) []accountTx {
+func (am *AccountManager) GetTransaction(txsha *btcwire.ShaHash) []accountTx {
 	accumulatedTxen := []accountTx{}
 
 	for _, a := range am.AllAccounts() {
-		for _, t := range a.TxStore {
+		for _, record := range a.TxStore.SortedRecords() {
-			if t.GetTxID().String() != txid {
+			if *record.TxSha() != *txsha {
 				continue
 			}
-			accumulatedTxen = append(accumulatedTxen,
+
-				accountTx{
+			atx := accountTx{
-					Account: a.name,
+				Account: a.name,
-					Tx:      t.Copy(),
+				Tx:      record,
-				})
+			}
+			accumulatedTxen = append(accumulatedTxen, atx)
 		}
 	}
 
@@ -509,53 +485,15 @@ func (am *AccountManager) ListUnspent(minconf, maxconf int,
 		return nil, err
 	}
 
-	replies := []map[string]interface{}{}
+	infos := []map[string]interface{}{}
 	for _, a := range am.AllAccounts() {
-		for _, u := range a.UtxoStore {
+		for _, record := range a.TxStore.UnspentOutputs() {
-			confirmations := 0
+			info := record.TxInfo(a.name, bs.Height, cfg.Net())[0]
-			if u.Height != -1 {
+			infos = append(infos, info)
-				confirmations = int(bs.Height - u.Height + 1)
-			}
-			if minconf != 0 && (u.Height == -1 ||
-				confirmations < minconf) {
-				continue
-			}
-			// check maxconf - doesn't apply if not confirmed.
-			if u.Height != -1 && confirmations > maxconf {
-				continue
-			}
-
-			addr, err := btcutil.NewAddressPubKeyHash(u.AddrHash[:],
-				cfg.Net())
-			if err != nil {
-				continue
-			}
-
-			// if we hve addresses, limit to that list.
-			if len(addresses) > 0 {
-				if _, ok := addresses[addr.EncodeAddress()]; !ok {
-					continue
-				}
-			}
-			entry := map[string]interface{}{
-				// check minconf/maxconf
-				"txid":          u.Out.Hash.String(),
-				"vout":          u.Out.Index,
-				"address":       addr.EncodeAddress(),
-				"account":       a.name,
-				"scriptPubKey":  u.Subscript,
-				"amount":        float64(u.Amt) / float64(btcutil.SatoshiPerBitcoin),
-				"confirmations": confirmations,
-				// TODO(oga) if the object is
-				// pay-to-script-hash we need to add the
-				// redeemscript.
-			}
-
-			replies = append(replies, entry)
 		}
 
 	}
-	return replies, nil
+	return infos, nil
 }
 
 // RescanActiveAddresses begins a rescan for all active addresses for
@@ -569,6 +507,12 @@ func (am *AccountManager) RescanActiveAddresses() {
 	}
 }
 
+func (am *AccountManager) ResendUnminedTxs() {
+	for _, account := range am.AllAccounts() {
+		account.ResendUnminedTxs()
+	}
+}
+
 // Track begins tracking all addresses in all accounts for updates from
 // btcd.
 func (am *AccountManager) Track() {

cmd.go

@@ -41,11 +41,6 @@ var (
 		Err: "wallet file does not exist",
 	}
 
-	// ErrNoUtxos describes an error where the wallet file was successfully
-	// read, but the UTXO file was not.  To properly handle this error,
-	// a rescan should be done since the wallet creation block.
-	ErrNoUtxos = errors.New("utxo file cannot be read")
-
 	// ErrNoTxs describes an error where the wallet and UTXO files were
 	// successfully read, but the TX history file was not.  It is up to
 	// the caller whether this necessitates a rescan or not.
@@ -190,7 +185,6 @@ func main() {
 	go StoreNotifiedMempoolRecvTxs(NotifiedRecvTxChans.add,
 		NotifiedRecvTxChans.remove,
 		NotifiedRecvTxChans.access)
-	go NotifyMinedTxSender(NotifyMinedTx)
 	go NotifyBalanceSyncer(NotifyBalanceSyncerChans.add,
 		NotifyBalanceSyncerChans.remove,
 		NotifyBalanceSyncerChans.access)
@@ -271,15 +265,16 @@ func OpenSavedAccount(name string, cfg *config) (*Account, error) {
 	}
 
 	wlt := new(wallet.Wallet)
+	txs := tx.NewStore()
 	a := &Account{
-		Wallet: wlt,
+		name:    name,
-		name:   name,
+		Wallet:  wlt,
+		TxStore: txs,
 	}
 
 	wfilepath := accountFilename("wallet.bin", name, netdir)
-	utxofilepath := accountFilename("utxo.bin", name, netdir)
 	txfilepath := accountFilename("tx.bin", name, netdir)
-	var wfile, utxofile, txfile *os.File
+	var wfile, txfile *os.File
 
 	// Read wallet file.
 	wfile, err := os.Open(wfilepath)
@@ -309,30 +304,10 @@ func OpenSavedAccount(name string, cfg *config) (*Account, error) {
 		finalErr = ErrNoTxs
 	} else {
 		defer txfile.Close()
-		var txs tx.TxStore
 		if _, err = txs.ReadFrom(txfile); err != nil {
 			log.Errorf("cannot read tx file: %s", err)
+			a.fullRescan = true
 			finalErr = ErrNoTxs
-		} else {
-			a.TxStore = txs
-		}
-	}
-
-	// Read utxo file.  If this fails, return a ErrNoUtxos error so a
-	// rescan can be done since the wallet creation block.
-	var utxos tx.UtxoStore
-	utxofile, err = os.Open(utxofilepath)
-	if err != nil {
-		log.Errorf("cannot open utxo file: %s", err)
-		finalErr = ErrNoUtxos
-		a.fullRescan = true
-	} else {
-		defer utxofile.Close()
-		if _, err = utxos.ReadFrom(utxofile); err != nil {
-			log.Errorf("cannot read utxo file: %s", err)
-			finalErr = ErrNoUtxos
-		} else {
-			a.UtxoStore = utxos
 		}
 	}
 

createtx.go

@@ -60,45 +60,23 @@ var TxFeeIncrement = struct {
 	i: minTxFee,
 }
 
-// CreatedTx is a type holding information regarding a newly-created
-// transaction, including the raw bytes, inputs, and an address and UTXO
-// for change (if any).
 type CreatedTx struct {
-	rawTx      []byte
+	tx        *btcutil.Tx
-	txid       btcwire.ShaHash
+	time      time.Time
-	time       time.Time
+	haschange bool
-	inputs     []*tx.Utxo
+	changeIdx uint32
-	outputs    []tx.Pair
-	btcspent   int64
-	fee        int64
-	changeAddr *btcutil.AddressPubKeyHash
-	changeUtxo *tx.Utxo
-}
-
-// TXID is a transaction hash identifying a transaction.
-type TXID btcwire.ShaHash
-
-// UnminedTXs holds a map of transaction IDs as keys mapping to a
-// CreatedTx structure.  If sending a raw transaction succeeds, the
-// tx is added to this map and checked again after each new block.
-// If the new block contains a tx, it is removed from this map.
-var UnminedTxs = struct {
-	sync.Mutex
-	m map[TXID]*CreatedTx
-}{
-	m: make(map[TXID]*CreatedTx),
 }
 
 // ByAmount defines the methods needed to satisify sort.Interface to
 // sort a slice of Utxos by their amount.
-type ByAmount []*tx.Utxo
+type ByAmount []*tx.RecvTxOut
 
 func (u ByAmount) Len() int {
 	return len(u)
 }
 
 func (u ByAmount) Less(i, j int) bool {
-	return u[i].Amt < u[j].Amt
+	return u[i].Value() < u[j].Value()
 }
 
 func (u ByAmount) Swap(i, j int) {
@@ -111,7 +89,9 @@ func (u ByAmount) Swap(i, j int) {
 // is the total number of satoshis which would be spent by the combination
 // of all selected previous outputs.  err will equal ErrInsufficientFunds if there
 // are not enough unspent outputs to spend amt.
-func selectInputs(s tx.UtxoStore, amt uint64, minconf int) (inputs []*tx.Utxo, btcout uint64, err error) {
+func selectInputs(utxos []*tx.RecvTxOut, amt int64,
+	minconf int) (selected []*tx.RecvTxOut, btcout int64, err error) {
+
 	bs, err := GetCurBlock()
 	if err != nil {
 		return nil, 0, err
@@ -120,13 +100,14 @@ func selectInputs(s tx.UtxoStore, amt uint64, minconf int) (inputs []*tx.Utxo, b
 	// Create list of eligible unspent previous outputs to use as tx
 	// inputs, and sort by the amount in reverse order so a minimum number
 	// of inputs is needed.
-	eligible := make([]*tx.Utxo, 0, len(s))
+	eligible := make([]*tx.RecvTxOut, 0, len(utxos))
-	for _, utxo := range s {
+	for _, utxo := range utxos {
-		// TODO(jrick): if Height is -1, the UTXO is the result of spending
+		if confirmed(minconf, utxo.Height(), bs.Height) {
-		// to a change address, resulting in a UTXO not yet mined in a block.
+			// Coinbase transactions must have 100 confirmations before
-		// For now, disallow creating transactions until these UTXOs are mined
+			// they may be spent.
-		// into a block and show up as part of the balance.
+			if utxo.IsCoinbase() && bs.Height-utxo.Height()+1 < 100 {
-		if confirmed(minconf, utxo.Height, bs.Height) {
+				continue
+			}
 			eligible = append(eligible, utxo)
 		}
 	}
@@ -135,17 +116,18 @@ func selectInputs(s tx.UtxoStore, amt uint64, minconf int) (inputs []*tx.Utxo, b
 	// Iterate throguh eligible transactions, appending to outputs and
 	// increasing btcout.  This is finished when btcout is greater than the
 	// requested amt to spend.
-	for _, u := range eligible {
+	for _, e := range eligible {
-		inputs = append(inputs, u)
+		selected = append(selected, e)
-		if btcout += u.Amt; btcout >= amt {
+		btcout += e.Value()
-			return inputs, btcout, nil
+		if btcout >= amt {
+			return selected, btcout, nil
 		}
 	}
 	if btcout < amt {
 		return nil, 0, ErrInsufficientFunds
 	}
 
-	return inputs, btcout, nil
+	return selected, btcout, nil
 }
 
 // txToPairs creates a raw transaction sending the amounts for each
@@ -171,10 +153,6 @@ func (a *Account) txToPairs(pairs map[string]int64, minconf int) (*CreatedTx, er
 		amt += v
 	}
 
-	// outputs is a tx.Pair slice representing each output that is created
-	// by the transaction.
-	outputs := make([]tx.Pair, 0, len(pairs)+1)
-
 	// Add outputs to new tx.
 	for addrStr, amt := range pairs {
 		addr, err := btcutil.DecodeAddr(addrStr)
@@ -189,13 +167,6 @@ func (a *Account) txToPairs(pairs map[string]int64, minconf int) (*CreatedTx, er
 		}
 		txout := btcwire.NewTxOut(int64(amt), pkScript)
 		msgtx.AddTxOut(txout)
-
-		// Create amount, address pair and add to outputs.
-		out := tx.Pair{
-			Amount:     amt,
-			PubkeyHash: addr.ScriptAddress(),
-		}
-		outputs = append(outputs, out)
 	}
 
 	// Get current block's height and hash.
@@ -213,9 +184,9 @@ func (a *Account) txToPairs(pairs map[string]int64, minconf int) (*CreatedTx, er
 	// again in case a change utxo has already been chosen.
 	var changeAddr *btcutil.AddressPubKeyHash
 
-	var btcspent int64
+	var selectedInputs []*tx.RecvTxOut
-	var selectedInputs []*tx.Utxo
+	hasChange := false
-	var finalChangeUtxo *tx.Utxo
+	changeIndex := uint32(0)
 
 	// Get the number of satoshis to increment fee by when searching for
 	// the minimum tx fee needed.
@@ -225,18 +196,20 @@ func (a *Account) txToPairs(pairs map[string]int64, minconf int) (*CreatedTx, er
 
 		// Select unspent outputs to be used in transaction based on the amount
 		// neededing to sent, and the current fee estimation.
-		inputs, btcin, err := selectInputs(a.UtxoStore, uint64(amt+fee),
+		inputs, btcin, err := selectInputs(a.TxStore.UnspentOutputs(),
-			minconf)
+			amt+fee, minconf)
 		if err != nil {
 			return nil, err
 		}
 
 		// Check if there are leftover unspent outputs, and return coins back to
 		// a new address we own.
-		var changeUtxo *tx.Utxo
+		change := btcin - amt - fee
-		change := btcin - uint64(amt+fee)
 		if change > 0 {
-			// Create a new address to spend leftover outputs to.
+			hasChange = true
+			// TODO: this needs to be randomly inserted into the
+			// tx, or else this is a privacy risk
+			changeIndex = 0
 
 			// Get a new change address if one has not already been found.
 			if changeAddr == nil {
@@ -255,43 +228,35 @@ func (a *Account) txToPairs(pairs map[string]int64, minconf int) (*CreatedTx, er
 				return nil, fmt.Errorf("cannot create txout script: %s", err)
 			}
 			msgtx.AddTxOut(btcwire.NewTxOut(int64(change), pkScript))
-
-			changeUtxo = &tx.Utxo{
-				Amt: change,
-				Out: tx.OutPoint{
-					// Hash is unset (zeroed) here and must be filled in
-					// with the transaction hash of the complete
-					// transaction.
-					Index: uint32(len(pairs)),
-				},
-				Height:    -1,
-				Subscript: pkScript,
-			}
-			copy(changeUtxo.AddrHash[:], changeAddr.ScriptAddress())
 		}
 
 		// Selected unspent outputs become new transaction's inputs.
 		for _, ip := range inputs {
-			msgtx.AddTxIn(btcwire.NewTxIn((*btcwire.OutPoint)(&ip.Out), nil))
+			msgtx.AddTxIn(btcwire.NewTxIn(ip.OutPoint(), nil))
 		}
-		for i, ip := range inputs {
+		for i, input := range inputs {
-			// Error is ignored as the length and network checks can never fail
+			_, addrs, _, _ := input.Addresses(cfg.Net())
-			// for these inputs.
+			if len(addrs) != 1 {
-			addr, _ := btcutil.NewAddressPubKeyHash(ip.AddrHash[:],
+				continue
-				a.Wallet.Net())
+			}
-			privkey, err := a.AddressKey(addr)
+			apkh, ok := addrs[0].(*btcutil.AddressPubKeyHash)
+			if !ok {
+				continue // don't handle inputs to this yes
+			}
+
+			privkey, err := a.AddressKey(apkh)
 			if err == wallet.ErrWalletLocked {
 				return nil, wallet.ErrWalletLocked
 			} else if err != nil {
 				return nil, fmt.Errorf("cannot get address key: %v", err)
 			}
-			ai, err := a.AddressInfo(addr)
+			ai, err := a.AddressInfo(apkh)
 			if err != nil {
 				return nil, fmt.Errorf("cannot get address info: %v", err)
 			}
 
 			sigscript, err := btcscript.SignatureScript(msgtx, i,
-				ip.Subscript, btcscript.SigHashAll, privkey,
+				input.PkScript(), btcscript.SigHashAll, privkey,
 				ai.Compressed)
 			if err != nil {
 				return nil, fmt.Errorf("cannot create sigscript: %s", err)
@@ -306,29 +271,7 @@ func (a *Account) txToPairs(pairs map[string]int64, minconf int) (*CreatedTx, er
 		if minFee := minimumFee(msgtx, noFeeAllowed); fee < minFee {
 			fee = minFee
 		} else {
-			// Fill Tx hash of change outpoint with transaction hash.
-			if changeUtxo != nil {
-				txHash, err := msgtx.TxSha()
-				if err != nil {
-					return nil, fmt.Errorf("cannot create transaction hash: %s", err)
-				}
-				copy(changeUtxo.Out.Hash[:], txHash[:])
-
-				// Add change to outputs.
-				out := tx.Pair{
-					Amount:     int64(change),
-					PubkeyHash: changeAddr.ScriptAddress(),
-					Change:     true,
-				}
-				outputs = append(outputs, out)
-
-				finalChangeUtxo = changeUtxo
-			}
-
 			selectedInputs = inputs
-
-			btcspent = int64(btcin)
-
 			break
 		}
 	}
@@ -341,7 +284,7 @@ func (a *Account) txToPairs(pairs map[string]int64, minconf int) (*CreatedTx, er
 	}
 	for i, txin := range msgtx.TxIn {
 		engine, err := btcscript.NewScript(txin.SignatureScript,
-			selectedInputs[i].Subscript, i, msgtx, flags)
+			selectedInputs[i].PkScript(), i, msgtx, flags)
 		if err != nil {
 			return nil, fmt.Errorf("cannot create script engine: %s", err)
 		}
@@ -350,23 +293,13 @@ func (a *Account) txToPairs(pairs map[string]int64, minconf int) (*CreatedTx, er
 		}
 	}
 
-	txid, err := msgtx.TxSha()
-	if err != nil {
-		return nil, fmt.Errorf("cannot create txid for created tx: %v", err)
-	}
-
 	buf := new(bytes.Buffer)
 	msgtx.BtcEncode(buf, btcwire.ProtocolVersion)
 	info := &CreatedTx{
-		rawTx:      buf.Bytes(),
+		tx:        btcutil.NewTx(msgtx),
-		txid:       txid,
+		time:      time.Now(),
-		time:       time.Now(),
+		haschange: hasChange,
-		inputs:     selectedInputs,
+		changeIdx: changeIndex,
-		outputs:    outputs,
-		btcspent:   btcspent,
-		fee:        fee,
-		changeAddr: changeAddr,
-		changeUtxo: finalChangeUtxo,
 	}
 	return info, nil
 }
@@ -406,14 +339,14 @@ func minimumFee(tx *btcwire.MsgTx, allowFree bool) int64 {
 // allowFree calculates the transaction priority and checks that the
 // priority reaches a certain threshhold.  If the threshhold is
 // reached, a free transaction fee is allowed.
-func allowFree(curHeight int32, inputs []*tx.Utxo, txSize int) bool {
+func allowFree(curHeight int32, txouts []*tx.RecvTxOut, txSize int) bool {
 	const blocksPerDayEstimate = 144
 	const txSizeEstimate = 250
 
 	var weightedSum int64
-	for _, utxo := range inputs {
+	for _, txout := range txouts {
-		depth := chainDepth(utxo.Height, curHeight)
+		depth := chainDepth(txout.Height(), curHeight)
-		weightedSum += int64(utxo.Amt) * int64(depth)
+		weightedSum += txout.Value() * int64(depth)
 	}
 	priority := float64(weightedSum) / float64(txSize)
 	return priority > float64(btcutil.SatoshiPerBitcoin)*blocksPerDayEstimate/txSizeEstimate

createtx_test.go

@@ -1,3 +1,12 @@
+// TODO(jrick) Due to the extra encapsulation added during the switch
+// to the new txstore, structures can no longer be mocked due to private
+// members.  Since all members for RecvTxOut and SignedTx are private, the
+// simplist solution would be to make RecvTxOut an interface and create
+// our own types satisifying the interface for this test package.  Until
+// then, disable this test.
+//
+// +build ignore
+
 package main
 
 import (

disksync.go

@@ -91,8 +91,8 @@ func checkCreateDir(path string) error {
 }
 
 // accountFilename returns the filepath of an account file given the
-// filename suffix ("wallet.bin", "tx.bin", or "utxo.bin"), account
+// filename suffix ("wallet.bin", or "tx.bin"), account name and the
-// name and the network directory holding the file.
+// network directory holding the file.
 func accountFilename(suffix, account, netdir string) string {
 	if account == "" {
 		// default account
@@ -109,7 +109,6 @@ type syncSchedule struct {
 	dir     string
 	wallets map[*Account]struct{}
 	txs     map[*Account]struct{}
-	utxos   map[*Account]struct{}
 }
 
 func newSyncSchedule(dir string) *syncSchedule {
@@ -117,7 +116,6 @@ func newSyncSchedule(dir string) *syncSchedule {
 		dir:     dir,
 		wallets: make(map[*Account]struct{}),
 		txs:     make(map[*Account]struct{}),
-		utxos:   make(map[*Account]struct{}),
 	}
 	return s
 }
@@ -125,12 +123,6 @@ func newSyncSchedule(dir string) *syncSchedule {
 // flushAccount writes all scheduled account files to disk for
 // a single account and removes them from the schedule.
 func (s *syncSchedule) flushAccount(a *Account) error {
-	if _, ok := s.utxos[a]; ok {
-		if err := a.writeUtxoStore(s.dir); err != nil {
-			return err
-		}
-		delete(s.utxos, a)
-	}
 	if _, ok := s.txs[a]; ok {
 		if err := a.writeTxStore(s.dir); err != nil {
 			return err
@@ -150,13 +142,6 @@ func (s *syncSchedule) flushAccount(a *Account) error {
 // flush writes all scheduled account files and removes each
 // from the schedule.
 func (s *syncSchedule) flush() error {
-	for a := range s.utxos {
-		if err := a.writeUtxoStore(s.dir); err != nil {
-			return err
-		}
-		delete(s.utxos, a)
-	}
-
 	for a := range s.txs {
 		if err := a.writeTxStore(s.dir); err != nil {
 			return err
@@ -196,9 +181,8 @@ type DiskSyncer struct {
 	flushAccount chan *flushAccountRequest
 
 	// Schedule file writes for an account.
-	scheduleWallet    chan *Account
+	scheduleWallet  chan *Account
-	scheduleTxStore   chan *Account
+	scheduleTxStore chan *Account
-	scheduleUtxoStore chan *Account
 
 	// Write a collection of accounts all at once.
 	writeBatch chan *writeBatchRequest
@@ -214,13 +198,12 @@ type DiskSyncer struct {
 // NewDiskSyncer creates a new DiskSyncer.
 func NewDiskSyncer(am *AccountManager) *DiskSyncer {
 	return &DiskSyncer{
-		flushAccount:      make(chan *flushAccountRequest),
+		flushAccount:    make(chan *flushAccountRequest),
-		scheduleWallet:    make(chan *Account),
+		scheduleWallet:  make(chan *Account),
-		scheduleTxStore:   make(chan *Account),
+		scheduleTxStore: make(chan *Account),
-		scheduleUtxoStore: make(chan *Account),
+		writeBatch:      make(chan *writeBatchRequest),
-		writeBatch:        make(chan *writeBatchRequest),
+		exportAccount:   make(chan *exportRequest),
-		exportAccount:     make(chan *exportRequest),
+		am:              am,
-		am:                am,
 	}
 }
 
@@ -275,12 +258,6 @@ func (ds *DiskSyncer) Start() {
 				timer = time.After(wait)
 			}
 
-		case a := <-ds.scheduleUtxoStore:
-			schedule.utxos[a] = struct{}{}
-			if timer == nil {
-				timer = time.After(wait)
-			}
-
 		case sr := <-ds.writeBatch:
 			err := batchWriteAccounts(sr.a, tmpnetdir, netdir)
 			if err == nil {
@@ -318,12 +295,6 @@ func (ds *DiskSyncer) ScheduleTxStoreWrite(a *Account) {
 	ds.scheduleTxStore <- a
 }
 
-// ScheduleUtxoStoreWrite schedules an account's utxo store to be written
-// to disk.
-func (ds *DiskSyncer) ScheduleUtxoStoreWrite(a *Account) {
-	ds.scheduleUtxoStore <- a
-}
-
 // WriteBatch safely replaces all account files in the network directory
 // with new files created from all accounts in a.
 func (ds *DiskSyncer) WriteBatch(a []*Account) error {
@@ -369,9 +340,6 @@ func batchWriteAccounts(accts []*Account, tmpdir, netdir string) error {
 }
 
 func (a *Account) writeAll(dir string) error {
-	if err := a.writeUtxoStore(dir); err != nil {
-		return err
-	}
 	if err := a.writeTxStore(dir); err != nil {
 		return err
 	}
@@ -424,25 +392,3 @@ func (a *Account) writeTxStore(dir string) error {
 
 	return nil
 }
-
-func (a *Account) writeUtxoStore(dir string) error {
-	utxofilepath := accountFilename("utxo.bin", a.name, dir)
-	_, filename := filepath.Split(utxofilepath)
-	tmpfile, err := ioutil.TempFile(dir, filename)
-	if err != nil {
-		return err
-	}
-
-	if _, err = a.UtxoStore.WriteTo(tmpfile); err != nil {
-		return err
-	}
-
-	tmppath := tmpfile.Name()
-	tmpfile.Close()
-
-	if err = Rename(tmppath, utxofilepath); err != nil {
-		return err
-	}
-
-	return nil
-}

ntfns.go

@@ -21,6 +21,7 @@ package main
 import (
 	"encoding/hex"
 	"github.com/conformal/btcjson"
+	"github.com/conformal/btcscript"
 	"github.com/conformal/btcutil"
 	"github.com/conformal/btcwallet/tx"
 	"github.com/conformal/btcwallet/wallet"
@@ -30,75 +31,73 @@ import (
 	"time"
 )
 
+func parseBlock(block *btcws.BlockDetails) (*tx.BlockDetails, error) {
+	if block == nil {
+		return nil, nil
+	}
+	blksha, err := btcwire.NewShaHashFromStr(block.Hash)
+	if err != nil {
+		return nil, err
+	}
+	return &tx.BlockDetails{
+		Height: block.Height,
+		Hash:   *blksha,
+		Index:  int32(block.Index),
+		Time:   time.Unix(block.Time, 0),
+	}, nil
+}
+
 type notificationHandler func(btcjson.Cmd)
 
 var notificationHandlers = map[string]notificationHandler{
 	btcws.BlockConnectedNtfnMethod:    NtfnBlockConnected,
 	btcws.BlockDisconnectedNtfnMethod: NtfnBlockDisconnected,
-	btcws.ProcessedTxNtfnMethod:       NtfnProcessedTx,
+	btcws.RecvTxNtfnMethod:            NtfnRecvTx,
-	btcws.TxMinedNtfnMethod:           NtfnTxMined,
+	btcws.RedeemingTxNtfnMethod:       NtfnRedeemingTx,
-	btcws.TxSpentNtfnMethod:           NtfnTxSpent,
 }
 
-// NtfnProcessedTx handles the btcws.ProcessedTxNtfn notification.
+// NtfnRecvTx handles the btcws.RecvTxNtfn notification.
-func NtfnProcessedTx(n btcjson.Cmd) {
+func NtfnRecvTx(n btcjson.Cmd) {
-	ptn, ok := n.(*btcws.ProcessedTxNtfn)
+	rtx, ok := n.(*btcws.RecvTxNtfn)
 	if !ok {
 		log.Errorf("%v handler: unexpected type", n.Method())
 		return
 	}
 
-	// Create useful types from the JSON strings.
+	bs, err := GetCurBlock()
-	receiver, err := btcutil.DecodeAddr(ptn.Receiver)
 	if err != nil {
-		log.Errorf("%v handler: error parsing receiver: %v", n.Method(), err)
+		log.Errorf("%v handler: cannot get current block: %v", n.Method(), err)
-		return
-	}
-	txID, err := btcwire.NewShaHashFromStr(ptn.TxID)
-	if err != nil {
-		log.Errorf("%v handler: error parsing txid: %v", n.Method(), err)
-		return
-	}
-	blockHash, err := btcwire.NewShaHashFromStr(ptn.BlockHash)
-	if err != nil {
-		log.Errorf("%v handler: error parsing block hash: %v", n.Method(), err)
-		return
-	}
-	pkscript, err := hex.DecodeString(ptn.PkScript)
-	if err != nil {
-		log.Errorf("%v handler: error parsing pkscript: %v", n.Method(), err)
 		return
 	}
 
-	// Lookup account for address in result.
+	rawTx, err := hex.DecodeString(rtx.HexTx)
-	aname, err := LookupAccountByAddress(ptn.Receiver)
+	if err != nil {
-	if err == ErrNotFound {
+		log.Errorf("%v handler: bad hexstring: err", n.Method(), err)
-		log.Warnf("Received rescan result for unknown address %v", ptn.Receiver)
 		return
 	}
-	a, err := AcctMgr.Account(aname)
+	tx_, err := btcutil.NewTxFromBytes(rawTx)
-	if err == ErrNotFound {
+	if err != nil {
-		log.Errorf("Missing account for rescaned address %v", ptn.Receiver)
+		log.Errorf("%v handler: bad transaction bytes: %v", n.Method(), err)
+		return
 	}
 
-	// Create RecvTx to add to tx history.
+	var block *tx.BlockDetails
-	t := &tx.RecvTx{
+	if rtx.Block != nil {
-		TxID:         *txID,
+		block, err = parseBlock(rtx.Block)
-		TxOutIdx:     ptn.TxOutIndex,
+		if err != nil {
-		TimeReceived: time.Now().Unix(),
+			log.Errorf("%v handler: bad block: %v", n.Method(), err)
-		BlockHeight:  ptn.BlockHeight,
+			return
-		BlockHash:    *blockHash,
+		}
-		BlockIndex:   int32(ptn.BlockIndex),
-		BlockTime:    ptn.BlockTime,
-		Amount:       ptn.Amount,
-		ReceiverHash: receiver.ScriptAddress(),
 	}
 
 	// For transactions originating from this wallet, the sent tx history should
 	// be recorded before the received history.  If wallet created this tx, wait
 	// for the sent history to finish being recorded before continuing.
+	//
+	// TODO(jrick) this is wrong due to tx malleability.  Cannot safely use the
+	// txsha as an identifier.
 	req := SendTxHistSyncRequest{
-		txid:     *txID,
+		txsha:    *tx_.Sha(),
 		response: make(chan SendTxHistSyncResponse),
 	}
 	SendTxHistSyncChans.access <- req
@@ -106,60 +105,64 @@ func NtfnProcessedTx(n btcjson.Cmd) {
 	if resp.ok {
 		// Wait until send history has been recorded.
 		<-resp.c
-		SendTxHistSyncChans.remove <- *txID
+		SendTxHistSyncChans.remove <- *tx_.Sha()
 	}
 
-	// Record the tx history.
+	// For every output, find all accounts handling that output address (if any)
-	a.TxStore.InsertRecvTx(t)
+	// and record the received txout.
-	AcctMgr.ds.ScheduleTxStoreWrite(a)
+	for outIdx, txout := range tx_.MsgTx().TxOut {
-	// Notify frontends of tx.  If the tx is unconfirmed, it is always
+		var accounts []*Account
-	// notified and the outpoint is marked as notified.  If the outpoint
+		var received time.Time
-	// has already been notified and is now in a block, a txmined notifiction
+		_, addrs, _, _ := btcscript.ExtractPkScriptAddrs(txout.PkScript, cfg.Net())
-	// should be sent once to let frontends that all previous send/recvs
+		for _, addr := range addrs {
-	// for this unconfirmed tx are now confirmed.
+			aname, err := LookupAccountByAddress(addr.EncodeAddress())
-	recvTxOP := btcwire.NewOutPoint(txID, ptn.TxOutIndex)
+			if err == ErrNotFound {
-	previouslyNotifiedReq := NotifiedRecvTxRequest{
+				continue
-		op:       *recvTxOP,
+			}
-		response: make(chan NotifiedRecvTxResponse),
+			// This cannot reasonably fail if the above succeeded.
-	}
+			a, _ := AcctMgr.Account(aname)
-	NotifiedRecvTxChans.access <- previouslyNotifiedReq
+			accounts = append(accounts, a)
-	if <-previouslyNotifiedReq.response {
-		NotifyMinedTx <- t
-		NotifiedRecvTxChans.remove <- *recvTxOP
-	} else {
-		// Notify frontends of new recv tx and mark as notified.
-		NotifiedRecvTxChans.add <- *recvTxOP
-		NotifyNewTxDetails(allClients, a.Name(), t.TxInfo(a.Name(),
-			ptn.BlockHeight, a.Wallet.Net())[0])
-	}
 
-	if !ptn.Spent {
+			if block != nil {
-		u := &tx.Utxo{
+				received = block.Time
-			Amt:       uint64(ptn.Amount),
+			} else {
-			Height:    ptn.BlockHeight,
+				received = time.Now()
-			Subscript: pkscript,
+			}
 		}
-		copy(u.Out.Hash[:], txID[:])
-		u.Out.Index = uint32(ptn.TxOutIndex)
-		copy(u.AddrHash[:], receiver.ScriptAddress())
-		copy(u.BlockHash[:], blockHash[:])
-		a.UtxoStore.Insert(u)
-		AcctMgr.ds.ScheduleUtxoStoreWrite(a)
 
-		// If this notification came from mempool, notify frontends of
+		for _, a := range accounts {
-		// the new unconfirmed balance immediately.  Otherwise, wait until
+			record := a.TxStore.InsertRecvTxOut(tx_, uint32(outIdx), false, received, block)
-		// the blockconnected notifiation is processed.
+			AcctMgr.ds.ScheduleTxStoreWrite(a)
-		if u.Height == -1 {
+
-			bal := a.CalculateBalance(0) - a.CalculateBalance(1)
+			// Notify frontends of tx.  If the tx is unconfirmed, it is always
-			NotifyWalletBalanceUnconfirmed(allClients, a.name, bal)
+			// notified and the outpoint is marked as notified.  If the outpoint
+			// has already been notified and is now in a block, a txmined notifiction
+			// should be sent once to let frontends that all previous send/recvs
+			// for this unconfirmed tx are now confirmed.
+			recvTxOP := btcwire.NewOutPoint(tx_.Sha(), uint32(outIdx))
+			previouslyNotifiedReq := NotifiedRecvTxRequest{
+				op:       *recvTxOP,
+				response: make(chan NotifiedRecvTxResponse),
+			}
+			NotifiedRecvTxChans.access <- previouslyNotifiedReq
+			if <-previouslyNotifiedReq.response {
+				NotifiedRecvTxChans.remove <- *recvTxOP
+			} else {
+				// Notify frontends of new recv tx and mark as notified.
+				NotifiedRecvTxChans.add <- *recvTxOP
+
+				// need access to the RecvTxOut to get the json info object
+				NotifyNewTxDetails(allClients, a.Name(),
+					record.TxInfo(a.Name(), bs.Height, a.Wallet.Net())[0])
+			}
+
+			// Notify frontends of new account balance.
+			confirmed := a.CalculateBalance(1)
+			unconfirmed := a.CalculateBalance(0) - confirmed
+			NotifyWalletBalance(allClients, a.name, confirmed)
+			NotifyWalletBalanceUnconfirmed(allClients, a.name, unconfirmed)
 		}
 	}
-
-	// Notify frontends of new account balance.
-	confirmed := a.CalculateBalance(1)
-	unconfirmed := a.CalculateBalance(0) - confirmed
-	NotifyWalletBalance(allClients, a.name, confirmed)
-	NotifyWalletBalanceUnconfirmed(allClients, a.name, unconfirmed)
 }
 
 // NtfnBlockConnected handles btcd notifications resulting from newly
@@ -233,42 +236,30 @@ func NtfnBlockDisconnected(n btcjson.Cmd) {
 	allClients <- marshaled
 }
 
-// NtfnTxMined handles btcd notifications resulting from newly
+// NtfnRedeemingTx handles btcd redeemingtx notifications resulting from a
-// mined transactions that originated from this wallet.
+// transaction spending a watched outpoint.
-func NtfnTxMined(n btcjson.Cmd) {
+func NtfnRedeemingTx(n btcjson.Cmd) {
-	tmn, ok := n.(*btcws.TxMinedNtfn)
+	cn, ok := n.(*btcws.RedeemingTxNtfn)
 	if !ok {
 		log.Errorf("%v handler: unexpected type", n.Method())
 		return
 	}
 
-	txid, err := btcwire.NewShaHashFromStr(tmn.TxID)
+	rawTx, err := hex.DecodeString(cn.HexTx)
 	if err != nil {
-		log.Errorf("%v handler: invalid hash string", n.Method())
+		log.Errorf("%v handler: bad hexstring: err", n.Method(), err)
 		return
 	}
-	blockhash, err := btcwire.NewShaHashFromStr(tmn.BlockHash)
+	tx_, err := btcutil.NewTxFromBytes(rawTx)
 	if err != nil {
-		log.Errorf("%v handler: invalid block hash string", n.Method())
+		log.Errorf("%v handler: bad transaction bytes: %v", n.Method(), err)
 		return
 	}
 
-	err = AcctMgr.RecordMinedTx(txid, blockhash,
+	block, err := parseBlock(cn.Block)
-		tmn.BlockHeight, tmn.Index, tmn.BlockTime)
 	if err != nil {
-		log.Errorf("%v handler: %v", n.Method(), err)
+		log.Errorf("%v handler: bad block: %v", n.Method(), err)
 		return
 	}
-
+	AcctMgr.RecordSpendingTx(tx_, block)
-	// Remove mined transaction from pool.
-	UnminedTxs.Lock()
-	delete(UnminedTxs.m, TXID(*txid))
-	UnminedTxs.Unlock()
-}
-
-// NtfnTxSpent handles btcd txspent notifications resulting from a block
-// transaction being processed that spents a wallet UTXO.
-func NtfnTxSpent(n btcjson.Cmd) {
-	// TODO(jrick): This might actually be useless and maybe it shouldn't
-	// be implemented.
 }

rpcclient.go

@@ -21,9 +21,11 @@ package main
 
 import (
 	"code.google.com/p/go.net/websocket"
+	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"github.com/conformal/btcjson"
+	"github.com/conformal/btcutil"
 	"github.com/conformal/btcwire"
 	"github.com/conformal/btcws"
 )
@@ -361,3 +363,39 @@ func SendRawTransaction(rpc ServerConn, hextx string) (txid string, error *btcjs
 	}
 	return *response.Result().(*string), nil
 }
+
+// GetRawTransaction sends the non-verbose version of a getrawtransaction
+// request to receive the serialized transaction referenced by txsha.  If
+// successful, the transaction is decoded and returned as a btcutil.Tx.
+func GetRawTransaction(rpc ServerConn, txsha *btcwire.ShaHash) (*btcutil.Tx, *btcjson.Error) {
+	// NewGetRawTransactionCmd cannot fail with no optargs.
+	cmd, _ := btcjson.NewGetRawTransactionCmd(<-NewJSONID, txsha.String())
+	request := NewServerRequest(cmd, new(string))
+	response := <-rpc.SendRequest(request)
+	if response.Error() != nil {
+		return nil, response.Error()
+	}
+	hextx := *response.Result().(*string)
+	serializedTx, err := hex.DecodeString(hextx)
+	if err != nil {
+		return nil, &btcjson.ErrDecodeHexString
+	}
+	utx, err := btcutil.NewTxFromBytes(serializedTx)
+	if err != nil {
+		return nil, &btcjson.ErrDeserialization
+	}
+	return utx, nil
+}
+
+// VerboseGetRawTransaction sends the verbose version of a getrawtransaction
+// request to receive details about a transaction.
+func VerboseGetRawTransaction(rpc ServerConn, txsha *btcwire.ShaHash) (*btcjson.TxRawResult, *btcjson.Error) {
+	// NewGetRawTransactionCmd cannot fail with a single optarg.
+	cmd, _ := btcjson.NewGetRawTransactionCmd(<-NewJSONID, txsha.String(), 1)
+	request := NewServerRequest(cmd, new(btcjson.TxRawResult))
+	response := <-rpc.SendRequest(request)
+	if response.Error() != nil {
+		return nil, response.Error()
+	}
+	return response.Result().(*btcjson.TxRawResult), nil
+}

rpcserver.go

@@ -17,10 +17,12 @@
 package main
 
 import (
+	"bytes"
 	"encoding/base64"
 	"encoding/hex"
 	"github.com/conformal/btcec"
 	"github.com/conformal/btcjson"
+	"github.com/conformal/btcscript"
 	"github.com/conformal/btcutil"
 	"github.com/conformal/btcwallet/tx"
 	"github.com/conformal/btcwallet/wallet"
@@ -791,33 +793,29 @@ func GetTransaction(icmd btcjson.Cmd) (interface{}, *btcjson.Error) {
 		return nil, &btcjson.ErrInternal
 	}
 
-	accumulatedTxen := AcctMgr.GetTransaction(cmd.Txid)
+	txsha, err := btcwire.NewShaHashFromStr(cmd.Txid)
+	if err != nil {
+		return nil, &btcjson.ErrDecodeHexString
+	}
+
+	accumulatedTxen := AcctMgr.GetTransaction(txsha)
 	if len(accumulatedTxen) == 0 {
 		return nil, &btcjson.ErrNoTxInfo
 	}
 
-	details := []map[string]interface{}{}
+	var sr *tx.SignedTx
-	totalAmount := int64(0)
+	var srAccount string
+	var amountReceived int64
+	var details []map[string]interface{}
 	for _, e := range accumulatedTxen {
-		switch t := e.Tx.(type) {
+		switch record := e.Tx.(type) {
-		case *tx.SendTx:
+		case *tx.RecvTxOut:
-			var amount int64
+			if record.Change() {
-			for i := range t.Receivers {
+				continue
-				if t.Receivers[i].Change {
-					continue
-				}
-				amount += t.Receivers[i].Amount
 			}
-			totalAmount -= amount
+
-			details = append(details, map[string]interface{}{
+			amountReceived += record.Value()
-				"account":  e.Account,
+			_, addrs, _, _ := record.Addresses(cfg.Net())
-				"category": "send",
-				// negative since it is a send
-				"amount": -amount,
-				"fee":    t.Fee,
-			})
-		case *tx.RecvTx:
-			totalAmount += t.Amount
 			details = append(details, map[string]interface{}{
 				"account": e.Account,
 				// TODO(oga) We don't mine for now so there
@@ -826,12 +824,32 @@ func GetTransaction(icmd btcjson.Cmd) (interface{}, *btcjson.Error) {
 				// specially with the category depending on
 				// whether it is an orphan or in the blockchain.
 				"category": "receive",
-				"amount":   t.Amount,
+				"amount":   float64(record.Value()) / float64(btcutil.SatoshiPerBitcoin),
-				"address":  hex.EncodeToString(t.ReceiverHash),
+				"address":  addrs[0].EncodeAddress(),
 			})
+
+		case *tx.SignedTx:
+			// there should only be a single SignedTx record, if any.
+			// If found, it will be added to the beginning.
+			sr = record
+			srAccount = e.Account
 		}
 	}
 
+	totalAmount := amountReceived
+	if sr != nil {
+		totalAmount -= sr.TotalSent()
+		info := map[string]interface{}{
+			"account":  srAccount,
+			"category": "send",
+			// negative since it is a send
+			"amount": -(sr.TotalSent() - amountReceived),
+			"fee":    sr.Fee(),
+		}
+		// Add sent information to front.
+		details = append([]map[string]interface{}{info}, details...)
+	}
+
 	// Generic information should be the same, so just use the first one.
 	first := accumulatedTxen[0]
 	ret := map[string]interface{}{
@@ -839,19 +857,19 @@ func GetTransaction(icmd btcjson.Cmd) (interface{}, *btcjson.Error) {
 		// "confirmations
 		"amount": totalAmount,
 
-		"txid": first.Tx.GetTxID().String(),
+		"txid": first.Tx.TxSha().String(),
 		// TODO(oga) technically we have different time and
 		// timereceived depending on if a transaction was send or
 		// receive. We ideally should provide the correct numbers for
 		// both. Right now they will always be the same
-		"time":         first.Tx.GetTime(),
+		"time":         first.Tx.Time().Unix(),
-		"timereceived": first.Tx.GetTime(),
+		"timereceived": first.Tx.Time().Unix(),
 		"details":      details,
 	}
-	if first.Tx.GetBlockHeight() != -1 {
+	if details := first.Tx.Block(); details != nil {
-		ret["blockindex"] = first.Tx.GetBlockHeight()
+		ret["blockindex"] = float64(details.Height)
-		ret["blockhash"] = first.Tx.GetBlockHash().String()
+		ret["blockhash"] = details.Hash.String()
-		ret["blocktime"] = first.Tx.GetBlockTime()
+		ret["blocktime"] = details.Time.Unix()
 		bs, err := GetCurBlock()
 		if err != nil {
 			return nil, &btcjson.Error{
@@ -859,7 +877,7 @@ func GetTransaction(icmd btcjson.Cmd) (interface{}, *btcjson.Error) {
 				Message: err.Error(),
 			}
 		}
-		ret["confirmations"] = bs.Height - first.Tx.GetBlockHeight() + 1
+		ret["confirmations"] = bs.Height - details.Height + 1
 	}
 	// TODO(oga) if the tx is a coinbase we should set "generated" to true.
 	// Since we do not mine this currently is never the case.
@@ -1158,11 +1176,14 @@ func sendPairs(icmd btcjson.Cmd, account string, amounts map[string]int64,
 
 	// Mark txid as having send history so handlers adding receive history
 	// wait until all send history has been written.
-	SendTxHistSyncChans.add <- createdTx.txid
+	SendTxHistSyncChans.add <- *createdTx.tx.Sha()
 
 	// If a change address was added, sync wallet to disk and request
 	// transaction notifications to the change address.
-	if createdTx.changeAddr != nil {
+	if createdTx.haschange {
+		script := createdTx.tx.MsgTx().TxOut[createdTx.changeIdx].PkScript
+		_, addrs, _, _ := btcscript.ExtractPkScriptAddrs(script, cfg.Net())
+
 		AcctMgr.ds.ScheduleWalletWrite(a)
 		if err := AcctMgr.ds.FlushAccount(a); err != nil {
 			e := btcjson.Error{
@@ -1171,22 +1192,19 @@ func sendPairs(icmd btcjson.Cmd, account string, amounts map[string]int64,
 			}
 			return nil, &e
 		}
-		a.ReqNewTxsForAddress(createdTx.changeAddr)
+		a.ReqNewTxsForAddress(addrs[0])
 	}
 
-	hextx := hex.EncodeToString(createdTx.rawTx)
+	serializedTx := new(bytes.Buffer)
-	// NewSendRawTransactionCmd will never fail so don't check error.
+	createdTx.tx.MsgTx().Serialize(serializedTx)
-	sendtx, _ := btcjson.NewSendRawTransactionCmd(<-NewJSONID, hextx)
+	hextx := hex.EncodeToString(serializedTx.Bytes())
-	request := NewServerRequest(sendtx, new(string))
+	txSha, jsonErr := SendRawTransaction(CurrentServerConn(), hextx)
-	response := <-CurrentServerConn().SendRequest(request)
+	if jsonErr != nil {
-	txid := *response.Result().(*string)
+		SendTxHistSyncChans.remove <- *createdTx.tx.Sha()
-
+		return nil, jsonErr
-	if response.Error() != nil {
-		SendTxHistSyncChans.remove <- createdTx.txid
-		return nil, response.Error()
 	}
 
-	return handleSendRawTxReply(icmd, txid, a, createdTx)
+	return handleSendRawTxReply(icmd, txSha, a, createdTx)
 }
 
 // SendFrom handles a sendfrom RPC request by creating a new transaction
@@ -1291,7 +1309,7 @@ var SendTxHistSyncChans = struct {
 // SendTxHistSyncRequest requests a SendTxHistSyncResponse from
 // SendBeforeReceiveHistorySync.
 type SendTxHistSyncRequest struct {
-	txid     btcwire.ShaHash
+	txsha    btcwire.ShaHash
 	response chan SendTxHistSyncResponse
 }
 
@@ -1302,8 +1320,8 @@ type SendTxHistSyncResponse struct {
 }
 
 // SendBeforeReceiveHistorySync manages a set of transaction hashes
-// created by this wallet.  For each newly added txid, a channel is
+// created by this wallet.  For each newly added txsha, a channel is
-// created.  Once the send history has been recorded, the txid should
+// created.  Once the send history has been recorded, the txsha should
 // be messaged across done, causing the internal channel to be closed.
 // Before receive history is recorded, access should be used to check
 // if there are or were any goroutines writing send history, and if
@@ -1314,61 +1332,43 @@ func SendBeforeReceiveHistorySync(add, done, remove chan btcwire.ShaHash,
 	m := make(map[btcwire.ShaHash]chan struct{})
 	for {
 		select {
-		case txid := <-add:
+		case txsha := <-add:
-			m[txid] = make(chan struct{})
+			m[txsha] = make(chan struct{})
 
-		case txid := <-remove:
+		case txsha := <-remove:
-			delete(m, txid)
+			delete(m, txsha)
 
-		case txid := <-done:
+		case txsha := <-done:
-			if c, ok := m[txid]; ok {
+			if c, ok := m[txsha]; ok {
 				close(c)
 			}
 
 		case req := <-access:
-			c, ok := m[req.txid]
+			c, ok := m[req.txsha]
 			req.response <- SendTxHistSyncResponse{c: c, ok: ok}
 		}
 	}
 }
 
 func handleSendRawTxReply(icmd btcjson.Cmd, txIDStr string, a *Account, txInfo *CreatedTx) (interface{}, *btcjson.Error) {
-	txID, err := btcwire.NewShaHashFromStr(txIDStr)
-	if err != nil {
-		e := btcjson.Error{
-			Code:    btcjson.ErrInternal.Code,
-			Message: "Invalid hash string from btcd reply",
-		}
-		return nil, &e
-	}
-
 	// Add to transaction store.
-	sendtx := &tx.SendTx{
+	stx := a.TxStore.InsertSignedTx(txInfo.tx, nil)
-		TxID:        *txID,
-		Time:        txInfo.time.Unix(),
-		BlockHeight: -1,
-		Fee:         txInfo.fee,
-		Receivers:   txInfo.outputs,
-	}
-	a.TxStore = append(a.TxStore, sendtx)
 	AcctMgr.ds.ScheduleTxStoreWrite(a)
 
 	// Notify frontends of new SendTx.
 	bs, err := GetCurBlock()
 	if err == nil {
-		for _, details := range sendtx.TxInfo(a.Name(), bs.Height, a.Net()) {
+		for _, details := range stx.TxInfo(a.Name(), bs.Height, a.Net()) {
-			NotifyNewTxDetails(allClients, a.Name(),
+			NotifyNewTxDetails(allClients, a.Name(), details)
-				details)
 		}
 	}
 
 	// Signal that received notifiations are ok to add now.
-	SendTxHistSyncChans.done <- txInfo.txid
+	SendTxHistSyncChans.done <- *txInfo.tx.Sha()
 
-	// Remove previous unspent outputs now spent by the tx.
+	// Add spending transaction to the store if it does not already exist,
-	if a.UtxoStore.Remove(txInfo.inputs) {
+	// marking all spent previous outputs.
-		AcctMgr.ds.ScheduleUtxoStoreWrite(a)
+	//a.TxStore.MarkSpendingTx(txInfo.tx, nil)
-	}
 
 	// Disk sync tx and utxo stores.
 	if err := AcctMgr.ds.FlushAccount(a); err != nil {
@@ -1382,18 +1382,6 @@ func handleSendRawTxReply(icmd btcjson.Cmd, txIDStr string, a *Account, txInfo *
 	NotifyWalletBalance(allClients, a.name, confirmed)
 	NotifyWalletBalanceUnconfirmed(allClients, a.name, unconfirmed)
 
-	// btcd cannot be trusted to successfully relay the tx to the
-	// Bitcoin network.  Even if this succeeds, the rawtx must be
-	// saved and checked for an appearence in a later block. btcd
-	// will make a best try effort, but ultimately it's btcwallet's
-	// responsibility.
-	//
-	// Add hex string of raw tx to sent tx pool.  If btcd disconnects
-	// and is reconnected, these txs are resent.
-	UnminedTxs.Lock()
-	UnminedTxs.m[TXID(*txID)] = txInfo
-	UnminedTxs.Unlock()
-
 	// The comments to be saved differ based on the underlying type
 	// of the cmd, so switch on the type to check whether it is a
 	// SendFromCmd or SendManyCmd.
@@ -1872,34 +1860,6 @@ func StoreNotifiedMempoolRecvTxs(add, remove chan btcwire.OutPoint,
 	}
 }
 
-// Channel to send received transactions that were previously
-// notified to frontends by the mempool.  A TxMined notification
-// is sent to all connected frontends detailing the block information
-// about the now confirmed transaction.
-var NotifyMinedTx = make(chan *tx.RecvTx)
-
-// NotifyMinedTxSender reads received transactions from in, notifying
-// frontends that the tx has now been confirmed in a block.  Duplicates
-// are filtered out.
-func NotifyMinedTxSender(in chan *tx.RecvTx) {
-	// Create a map to hold a set of already notified
-	// txids.  Do not send duplicates.
-	m := make(map[btcwire.ShaHash]struct{})
-
-	for recv := range in {
-		if _, ok := m[recv.TxID]; !ok {
-			ntfn := btcws.NewTxMinedNtfn(recv.TxID.String(),
-				recv.BlockHash.String(), recv.BlockHeight,
-				recv.BlockTime, int(recv.BlockIndex))
-			mntfn, _ := ntfn.MarshalJSON()
-			allClients <- mntfn
-
-			// Mark as sent.
-			m[recv.TxID] = struct{}{}
-		}
-	}
-}
-
 // NotifyBalanceSyncerChans holds channels for accessing
 // the NotifyBalanceSyncer goroutine.
 var NotifyBalanceSyncerChans = struct {

sockets.go

@@ -23,7 +23,6 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"encoding/base64"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -377,10 +376,9 @@ var duplicateOnce sync.Once
 // Start starts a HTTP server to provide standard RPC and extension
 // websocket connections for any number of btcwallet frontends.
 func (s *server) Start() {
-	// We'll need to duplicate replies to frontends to each frontend.
+	// A duplicator for notifications intended for all clients runs
-	// Replies are sent to frontendReplyMaster, and duplicated to each valid
+	// in another goroutines.  Any such notifications are sent to
-	// channel in frontendReplySet.  This runs a goroutine to duplicate
+	// the allClients channel and then sent to each connected client.
-	// requests for each channel in the set.
 	//
 	// Use a sync.Once to insure no extra duplicators run.
 	go duplicateOnce.Do(clientResponseDuplicator)
@@ -499,20 +497,6 @@ func BtcdConnect(certificates []byte) (*BtcdRPCConn, error) {
 	return rpc, nil
 }
 
-// resendUnminedTxs resends any transactions in the unmined transaction
-// pool to btcd using the 'sendrawtransaction' RPC command.
-func resendUnminedTxs() {
-	for _, createdTx := range UnminedTxs.m {
-		hextx := hex.EncodeToString(createdTx.rawTx)
-		if txid, err := SendRawTransaction(CurrentServerConn(), hextx); err != nil {
-			// TODO(jrick): Check error for if this tx is a double spend,
-			// remove it if so.
-		} else {
-			log.Debugf("Resent unmined transaction %v", txid)
-		}
-	}
-}
-
 // Handshake first checks that the websocket connection between btcwallet and
 // btcd is valid, that is, that there are no mismatching settings between
 // the two processes (such as running on different Bitcoin networks).  If the
@@ -591,7 +575,7 @@ func Handshake(rpc ServerConn) error {
 		AcctMgr.RescanActiveAddresses()
 
 		// (Re)send any unmined transactions to btcd in case of a btcd restart.
-		resendUnminedTxs()
+		AcctMgr.ResendUnminedTxs()
 
 		// Get current blockchain height and best block hash.
 		return nil
@@ -607,6 +591,6 @@ func Handshake(rpc ServerConn) error {
 	a.fullRescan = true
 	AcctMgr.Track()
 	AcctMgr.RescanActiveAddresses()
-	resendUnminedTxs()
+	AcctMgr.ResendUnminedTxs()
 	return nil
 }

tx/fixedIO_test.go

@@ -0,0 +1,41 @@
+// copied from btcwire
+
+// Copyright (c) 2013-2014 Conformal Systems LLC.
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package tx_test
+
+import (
+	"io"
+)
+
+// fixedWriter implements the io.Writer interface and intentially allows
+// testing of error paths by forcing short writes.
+type fixedWriter struct {
+	b   []byte
+	pos int
+}
+
+// Write ...
+func (w *fixedWriter) Write(p []byte) (n int, err error) {
+	lenp := len(p)
+	if w.pos+lenp > cap(w.b) {
+		return 0, io.ErrShortWrite
+	}
+	n = lenp
+	w.pos += copy(w.b[w.pos:], p)
+	return
+}
+
+// Bytes ...
+func (w *fixedWriter) Bytes() []byte {
+	return w.b
+}
+
+// newFixedWriter...
+func newFixedWriter(max int64) *fixedWriter {
+	b := make([]byte, max, max)
+	fw := fixedWriter{b, 0}
+	return &fw
+}

tx/tx_test.go

@@ -14,295 +14,338 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-package tx
+package tx_test
 
 import (
 	"bytes"
-	"code.google.com/p/go.crypto/ripemd160"
+	"encoding/hex"
-	"github.com/conformal/btcwire"
-	"github.com/davecgh/go-spew/spew"
-	"io"
-	"reflect"
 	"testing"
+	"time"
+
+	"github.com/conformal/btcutil"
+	. "github.com/conformal/btcwallet/tx"
+	"github.com/conformal/btcwire"
 )
 
+// Received transaction output for mainnet outpoint
+// 61d3696de4c888730cbe06b0ad8ecb6d72d6108e893895aa9bc067bd7eba3fad:0
 var (
-	recvtx = &RecvTx{
+	TstRecvSerializedTx, _          = hex.DecodeString("010000000114d9ff358894c486b4ae11c2a8cf7851b1df64c53d2e511278eff17c22fb7373000000008c493046022100995447baec31ee9f6d4ec0e05cb2a44f6b817a99d5f6de167d1c75354a946410022100c9ffc23b64d770b0e01e7ff4d25fbc2f1ca8091053078a247905c39fce3760b601410458b8e267add3c1e374cf40f1de02b59213a82e1d84c2b94096e22e2f09387009c96debe1d0bcb2356ffdcf65d2a83d4b34e72c62eccd8490dbf2110167783b2bffffffff0280969800000000001976a914479ed307831d0ac19ebc5f63de7d5f1a430ddb9d88ac38bfaa00000000001976a914dadf9e3484f28b385ddeaa6c575c0c0d18e9788a88ac00000000")
-		TxID: [btcwire.HashSize]byte{
+	TstRecvTx, _                    = btcutil.NewTxFromBytes(TstRecvSerializedTx)
-			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	TstRecvTxSpendingTxBlockHash, _ = btcwire.NewShaHashFromStr("00000000000000017188b968a371bab95aa43522665353b646e41865abae02a4")
-			16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+	TstRecvAmt                      = int64(10000000)
-			30, 31,
+	TstRecvTxBlockDetails           = &BlockDetails{
-		},
+		Height: 276425,
-		TxOutIdx: 0,
+		Hash:   *TstRecvTxSpendingTxBlockHash,
-		BlockHash: [btcwire.HashSize]byte{
+		Index:  684,
-			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+		Time:   time.Unix(1387737310, 0),
-			16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
-			30, 31,
-		},
-		BlockHeight: 69,
-		Amount:      69,
-		ReceiverHash: []byte{
-			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-			16, 17, 18, 19,
-		},
 	}
 
-	sendtx = &SendTx{
+	TstRecvCurrentHeight = int32(284498) // mainnet blockchain height at time of writing
-		TxID: [btcwire.HashSize]byte{
+	TstRecvTxOutConfirms = 8074          // hardcoded number of confirmations given the above block height
-			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+
-			16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+	TstSpendingTxBlockHeight = int32(279143)
-			30, 31,
+	TstSignedTxBlockHash, _  = btcwire.NewShaHashFromStr("00000000000000017188b968a371bab95aa43522665353b646e41865abae02a4")
-		},
+	TstSignedTxBlockDetails  = &BlockDetails{
-		Time: 12345,
+		Height: TstSpendingTxBlockHeight,
-		BlockHash: [btcwire.HashSize]byte{
+		Hash:   *TstSignedTxBlockHash,
-			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+		Index:  123,
-			16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+		Time:   time.Unix(1389114091, 0),
-			30, 31,
-		},
-		BlockHeight: 69,
-		BlockTime:   54321,
-		BlockIndex:  3,
-		Receivers: []Pair{
-			Pair{
-				PubkeyHash: []byte{
-					20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
-					34, 35, 36, 37, 38, 39,
-				},
-				Amount: 69,
-			},
-			Pair{
-				PubkeyHash: []byte{
-					40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
-					54, 55, 56, 57, 58, 59,
-				},
-				Amount: 96,
-			},
-		},
 	}
 )
 
-func TestUtxoWriteRead(t *testing.T) {
+func TestTxStore(t *testing.T) {
-	utxo1 := &Utxo{
+	// Create a double spend of the received blockchain transaction.
-		AddrHash: [ripemd160.Size]byte{
+	dupRecvTx, _ := btcutil.NewTxFromBytes(TstRecvSerializedTx)
-			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	// Switch txout amount to 1 BTC.  Transaction store doesn't
-			16, 17, 18, 19,
+	// validate txs, so this is fine for testing a double spend
-		},
+	// removal.
-		Out: OutPoint{
+	TstDupRecvAmount := int64(1e8)
-			Hash: [btcwire.HashSize]byte{
+	newDupMsgTx := dupRecvTx.MsgTx()
-				0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	newDupMsgTx.TxOut[0].Value = TstDupRecvAmount
-				16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+	TstDoubleSpendTx := btcutil.NewTx(newDupMsgTx)
-				30, 31,
+
+	// Create a "signed" (with invalid sigs) tx that spends output 0 of
+	// the double spend.
+	spendingTx := btcwire.NewMsgTx()
+	spendingTxIn := btcwire.NewTxIn(btcwire.NewOutPoint(TstDoubleSpendTx.Sha(), 0), []byte{0, 1, 2, 3, 4})
+	spendingTx.AddTxIn(spendingTxIn)
+	spendingTxOut1 := btcwire.NewTxOut(1e7, []byte{5, 6, 7, 8, 9})
+	spendingTxOut2 := btcwire.NewTxOut(9e7, []byte{10, 11, 12, 13, 14})
+	spendingTx.AddTxOut(spendingTxOut1)
+	spendingTx.AddTxOut(spendingTxOut2)
+	TstSpendingTx := btcutil.NewTx(spendingTx)
+
+	tests := []struct {
+		name     string
+		f        func(*Store) *Store
+		bal, unc int64
+		unspents map[btcwire.OutPoint]struct{}
+		unmined  map[btcwire.ShaHash]struct{}
+	}{
+		{
+			name: "new store",
+			f: func(_ *Store) *Store {
+				return NewStore()
 			},
-			Index: 1,
+			bal:      0,
+			unc:      0,
+			unspents: map[btcwire.OutPoint]struct{}{},
+			unmined:  map[btcwire.ShaHash]struct{}{},
+		},
+		{
+			name: "txout insert",
+			f: func(s *Store) *Store {
+				s.InsertRecvTxOut(TstRecvTx, 0, false, time.Now(), nil)
+				return s
+			},
+			bal: 0,
+			unc: TstRecvTx.MsgTx().TxOut[0].Value,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{},
+		},
+		{
+			name: "confirmed txout insert",
+			f: func(s *Store) *Store {
+				s.InsertRecvTxOut(TstRecvTx, 0, false, TstRecvTxBlockDetails.Time, TstRecvTxBlockDetails)
+				return s
+			},
+			bal: TstRecvTx.MsgTx().TxOut[0].Value,
+			unc: 0,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{},
+		},
+		{
+			name: "insert duplicate confirmed",
+			f: func(s *Store) *Store {
+				s.InsertRecvTxOut(TstRecvTx, 0, false, TstRecvTxBlockDetails.Time, TstRecvTxBlockDetails)
+				return s
+			},
+			bal: TstRecvTx.MsgTx().TxOut[0].Value,
+			unc: 0,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{},
+		},
+		{
+			name: "insert duplicate unconfirmed",
+			f: func(s *Store) *Store {
+				s.InsertRecvTxOut(TstRecvTx, 0, false, time.Now(), nil)
+				return s
+			},
+			bal: TstRecvTx.MsgTx().TxOut[0].Value,
+			unc: 0,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{},
+		},
+		{
+			name: "insert double spend with new txout value",
+			f: func(s *Store) *Store {
+				s.InsertRecvTxOut(TstDoubleSpendTx, 0, false, TstRecvTxBlockDetails.Time, TstRecvTxBlockDetails)
+				return s
+			},
+			bal: TstDoubleSpendTx.MsgTx().TxOut[0].Value,
+			unc: 0,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstDoubleSpendTx.Sha(), 0): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{},
+		},
+		{
+			name: "insert unconfirmed signed tx",
+			f: func(s *Store) *Store {
+				s.InsertSignedTx(TstSpendingTx, nil)
+				return s
+			},
+			bal:      0,
+			unc:      0,
+			unspents: map[btcwire.OutPoint]struct{}{},
+			unmined: map[btcwire.ShaHash]struct{}{
+				*TstSpendingTx.Sha(): struct{}{},
+			},
+		},
+		{
+			name: "insert unconfirmed signed tx again",
+			f: func(s *Store) *Store {
+				s.InsertSignedTx(TstSpendingTx, nil)
+				return s
+			},
+			bal:      0,
+			unc:      0,
+			unspents: map[btcwire.OutPoint]struct{}{},
+			unmined: map[btcwire.ShaHash]struct{}{
+				*TstSpendingTx.Sha(): struct{}{},
+			},
+		},
+		{
+			name: "insert change (index 0)",
+			f: func(s *Store) *Store {
+				s.InsertRecvTxOut(TstSpendingTx, 0, true, time.Now(), nil)
+				return s
+			},
+			bal: 0,
+			unc: TstSpendingTx.MsgTx().TxOut[0].Value,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{
+				*TstSpendingTx.Sha(): struct{}{},
+			},
+		},
+		{
+			name: "insert output back to this own wallet (index 1)",
+			f: func(s *Store) *Store {
+				s.InsertRecvTxOut(TstSpendingTx, 1, true, time.Now(), nil)
+				return s
+			},
+			bal: 0,
+			unc: TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): struct{}{},
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{
+				*TstSpendingTx.Sha(): struct{}{},
+			},
+		},
+		{
+			name: "confirmed signed tx",
+			f: func(s *Store) *Store {
+				s.InsertSignedTx(TstSpendingTx, TstSignedTxBlockDetails)
+				return s
+			},
+			bal: TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value,
+			unc: 0,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): struct{}{},
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{},
+		},
+		{
+			name: "rollback after spending tx",
+			f: func(s *Store) *Store {
+				s.Rollback(TstSignedTxBlockDetails.Height + 1)
+				return s
+			},
+			bal: TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value,
+			unc: 0,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): struct{}{},
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{},
+		},
+		{
+			name: "rollback spending tx block",
+			f: func(s *Store) *Store {
+				s.Rollback(TstSignedTxBlockDetails.Height)
+				return s
+			},
+			bal: 0,
+			unc: TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): struct{}{},
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{
+				*TstSpendingTx.Sha(): struct{}{},
+			},
+		},
+		{
+			name: "rollback double spend tx block",
+			f: func(s *Store) *Store {
+				s.Rollback(TstRecvTxBlockDetails.Height)
+				return s
+			},
+			bal: 0,
+			unc: TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): struct{}{},
+				*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{
+				*TstSpendingTx.Sha(): struct{}{},
+			},
+		},
+		{
+			name: "insert original recv txout",
+			f: func(s *Store) *Store {
+				s.InsertRecvTxOut(TstRecvTx, 0, false, TstRecvTxBlockDetails.Time, TstRecvTxBlockDetails)
+				return s
+			},
+			bal: TstRecvTx.MsgTx().TxOut[0].Value,
+			unc: 0,
+			unspents: map[btcwire.OutPoint]struct{}{
+				*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): struct{}{},
+			},
+			unmined: map[btcwire.ShaHash]struct{}{},
 		},
-		Subscript: []byte{},
-		Amt:       69,
-		Height:    1337,
-	}
-	bufWriter := &bytes.Buffer{}
-	written, err := utxo1.WriteTo(bufWriter)
-	if err != nil {
-		t.Error(err)
-	}
-	utxoBytes := bufWriter.Bytes()
-
-	utxo2 := new(Utxo)
-	read, err := utxo2.ReadFrom(bytes.NewBuffer(utxoBytes))
-	if err != nil {
-		t.Error(err)
-	}
-	if written != read {
-		t.Error("Reading and Writing Utxo: Size Mismatch")
 	}
 
-	if !reflect.DeepEqual(utxo1, utxo2) {
+	var s *Store
-		spew.Dump(utxo1, utxo2)
+	for _, test := range tests {
-		t.Error("Utxos do not match.")
+		s = test.f(s)
-	}
+		bal := s.Balance(1, TstRecvCurrentHeight)
-
+		if bal != test.bal {
-	truncatedReadBuf := bytes.NewBuffer(utxoBytes)
+			t.Errorf("%s: balance mismatch: expected %d, got %d", test.name, test.bal, bal)
-	truncatedReadBuf.Truncate(btcwire.HashSize)
-	utxo3 := new(Utxo)
-	n, err := utxo3.ReadFrom(truncatedReadBuf)
-	if err != io.EOF {
-		t.Error("Expected err = io.EOF reading from truncated buffer.")
-	}
-	if n != btcwire.HashSize {
-		t.Error("Incorrect number of bytes read from truncated buffer.")
-	}
-}
-
-func TestUtxoStoreWriteRead(t *testing.T) {
-	store1 := new(UtxoStore)
-	for i := 0; i < 20; i++ {
-		utxo := new(Utxo)
-		for j := range utxo.Out.Hash[:] {
-			utxo.Out.Hash[j] = byte(i + 1)
 		}
-		utxo.Out.Index = uint32(i + 2)
+		unc := s.Balance(0, TstRecvCurrentHeight) - bal
-		utxo.Subscript = []byte{}
+		if unc != test.unc {
-		utxo.Amt = uint64(i + 3)
+			t.Errorf("%s: unconfimred balance mismatch: expected %d, got %d", test.name, test.unc, unc)
-		utxo.Height = int32(i + 4)
-		utxo.BlockHash = [btcwire.HashSize]byte{
-			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-			16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
-			30, 31,
 		}
-		*store1 = append(*store1, utxo)
-	}
 
-	bufWriter := &bytes.Buffer{}
+		// Check that unspent outputs match expected.
-	nWritten, err := store1.WriteTo(bufWriter)
+		for _, record := range s.UnspentOutputs() {
-	if err != nil {
+			if record.Spent() {
-		t.Error(err)
+				t.Errorf("%s: unspent record marked as spent", test.name)
-	}
+			}
-	if nWritten != int64(bufWriter.Len()) {
-		t.Errorf("Wrote %v bytes but write buffer has %v bytes.", nWritten, bufWriter.Len())
-	}
 
-	storeBytes := bufWriter.Bytes()
+			op := *record.OutPoint()
-	bufReader := bytes.NewBuffer(storeBytes)
+			if _, ok := test.unspents[op]; !ok {
-	if nWritten != int64(bufReader.Len()) {
+				t.Errorf("%s: unexpected unspent output: %v", test.name, op)
-		t.Errorf("Wrote %v bytes but read buffer has %v bytes.", nWritten, bufReader.Len())
+			}
-	}
+			delete(test.unspents, op)
+		}
+		if len(test.unspents) != 0 {
+			t.Errorf("%s: missing expected unspent output(s)", test.name)
+		}
 
-	store2 := new(UtxoStore)
+		// Check that unmined signed txs match expected.
-	nRead, err := store2.ReadFrom(bufReader)
+		for _, tx := range s.UnminedSignedTxs() {
-	if err != nil {
+			if _, ok := test.unmined[*tx.Sha()]; !ok {
-		t.Error(err)
+				t.Errorf("%s: unexpected unmined signed tx: %v", test.name, *tx.Sha())
-	}
+			}
-	if nWritten != nRead {
+			delete(test.unmined, *tx.Sha())
-		t.Errorf("Bytes written (%v) does not match bytes read (%v).", nWritten, nRead)
+		}
-	}
+		if len(test.unmined) != 0 {
+			t.Errorf("%s: missing expected unmined signed tx(s)", test.name)
+		}
 
-	if !reflect.DeepEqual(store1, store2) {
+		// Pass a re-serialized version of the store to each next test.
-		spew.Dump(store1, store2)
+		buf := new(bytes.Buffer)
-		t.Error("Stores do not match.")
+		nWritten, err := s.WriteTo(buf)
-	}
+		if err != nil {
-
+			t.Fatalf("%v: serialization failed: %v (wrote %v bytes)", test.name, err, nWritten)
-	truncatedLen := 101
+		}
-	truncatedReadBuf := bytes.NewBuffer(storeBytes[:truncatedLen])
+		if nWritten != int64(buf.Len()) {
-	store3 := new(UtxoStore)
+			t.Errorf("%v: wrote %v bytes but buffer has %v", test.name, nWritten, buf.Len())
-	n, err := store3.ReadFrom(truncatedReadBuf)
+		}
-	if err != io.EOF {
+		nRead, err := s.ReadFrom(buf)
-		t.Errorf("Expected err = io.EOF reading from truncated buffer, got: %v", err)
+		if err != nil {
-	}
+			t.Fatalf("%v: deserialization failed: %v (read %v bytes after writing %v)",
-	if int(n) != truncatedLen {
+				test.name, err, nRead, nWritten)
-		t.Errorf("Incorrect number of bytes (%v) read from truncated buffer (len %v).", n, truncatedLen)
+		}
-	}
+		if nWritten != nRead {
-}
+			t.Errorf("%v: number of bytes written (%v) does not match those read (%v)",
-
+				test.name, nWritten, nRead)
-func TestRecvTxWriteRead(t *testing.T) {
+		}
-	bufWriter := &bytes.Buffer{}
-	n, err := recvtx.WriteTo(bufWriter)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	txBytes := bufWriter.Bytes()
-
-	tx := new(RecvTx)
-	n, err = tx.ReadFrom(bytes.NewBuffer(txBytes))
-	if err != nil {
-		t.Errorf("Read %v bytes before erroring with: %v", n, err)
-		return
-	}
-
-	if !reflect.DeepEqual(recvtx, tx) {
-		t.Error("Txs do not match.")
-		return
-	}
-
-	truncatedReadBuf := bytes.NewBuffer(txBytes)
-	truncatedReadBuf.Truncate(btcwire.HashSize)
-	n, err = tx.ReadFrom(truncatedReadBuf)
-	if err != io.EOF {
-		t.Error("Expected err = io.EOF reading from truncated buffer.")
-		return
-	}
-	if n != btcwire.HashSize {
-		t.Error("Incorrect number of bytes read from truncated buffer.")
-		return
-	}
-}
-
-func TestSendTxWriteRead(t *testing.T) {
-	bufWriter := &bytes.Buffer{}
-	n1, err := sendtx.WriteTo(bufWriter)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	txBytes := bufWriter.Bytes()
-
-	tx := new(SendTx)
-	n2, err := tx.ReadFrom(bytes.NewBuffer(txBytes))
-	if err != nil {
-		t.Errorf("Read %v bytes before erroring with: %v", n2, err)
-		return
-	}
-	if n1 != n2 {
-		t.Errorf("Number of bytes written and read mismatch, %d != %d",
-			n1, n2)
-		return
-	}
-
-	if !reflect.DeepEqual(sendtx, tx) {
-		t.Error("Txs do not match.")
-		return
-	}
-
-	truncatedReadBuf := bytes.NewBuffer(txBytes)
-	truncatedReadBuf.Truncate(btcwire.HashSize)
-	n, err := tx.ReadFrom(truncatedReadBuf)
-	if err != io.EOF {
-		t.Error("Expected err = io.EOF reading from truncated buffer.")
-		return
-	}
-	if n != btcwire.HashSize {
-		t.Error("Incorrect number of bytes read from truncated buffer.")
-		return
-	}
-}
-
-func TestTxStoreWriteRead(t *testing.T) {
-	s := []Tx{recvtx, sendtx}
-	store := TxStore(s)
-
-	bufWriter := &bytes.Buffer{}
-	n1, err := store.WriteTo(bufWriter)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	txsBytes := bufWriter.Bytes()
-
-	txs := TxStore{}
-	n2, err := txs.ReadFrom(bytes.NewBuffer(txsBytes))
-	if err != nil {
-		t.Errorf("Read %v bytes before erroring with: %v", n2, err)
-		return
-	}
-	if n1 != n2 {
-		t.Error("Number of bytes written and read mismatch.")
-		return
-	}
-
-	if !reflect.DeepEqual(store, txs) {
-		spew.Dump(store, txs)
-		t.Error("TxStores do not match.")
-		return
-	}
-
-	truncatedReadBuf := bytes.NewBuffer(txsBytes)
-	truncatedReadBuf.Truncate(50)
-	n, err := txs.ReadFrom(truncatedReadBuf)
-	if err != io.EOF {
-		t.Error("Expected err = io.EOF reading from truncated buffer.")
-		return
-	}
-	if n != 50 {
-		t.Error("Incorrect number of bytes read from truncated buffer.")
-		return
 	}
 }