LBRYCommunity/lbcwallet
1
0
Fork 0
Code Issues 5 Pull requests Projects Releases 14 Packages Wiki Activity

Update btcwire path import paths to new location.

Browse source
This commit is contained in:
Dave Collins 2015-02-05 15:41:38 -06:00
parent 1b7cd45029
commit 23c9dc423e
19 changed files with 191 additions and 191 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
chain/chain.go
View file

@ -21,12 +21,12 @@ import (
"sync"
"time"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcrpcclient"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/keystore"
"github.com/btcsuite/btcwallet/txstore"
"github.com/btcsuite/btcwire"
"github.com/btcsuite/btcws"
)
@ -162,12 +162,12 @@ type (
Block *txstore.Block // nil if unmined
}
RescanProgress struct {
Hash *btcwire.ShaHash
Hash *wire.ShaHash
Height int32
Time time.Time
}
RescanFinished struct {
Hash *btcwire.ShaHash
Hash *wire.ShaHash
Height int32
Time time.Time
}
@ -180,7 +180,7 @@ func parseBlock(block *btcws.BlockDetails) (blk *txstore.Block, idx int, err err
if block == nil {
return nil, btcutil.TxIndexUnknown, nil
}
blksha, err := btcwire.NewShaHashFromStr(block.Hash)
blksha, err := wire.NewShaHashFromStr(block.Hash)
if err != nil {
return nil, btcutil.TxIndexUnknown, err
}
@ -197,11 +197,11 @@ func (c *Client) onClientConnect() {
c.notifyConnected(true)
}
func (c *Client) onBlockConnected(hash *btcwire.ShaHash, height int32) {
func (c *Client) onBlockConnected(hash *wire.ShaHash, height int32) {
c.enqueueNotification <- BlockConnected{Hash: hash, Height: height}
}
func (c *Client) onBlockDisconnected(hash *btcwire.ShaHash, height int32) {
func (c *Client) onBlockDisconnected(hash *wire.ShaHash, height int32) {
c.enqueueNotification <- BlockDisconnected{Hash: hash, Height: height}
}
@ -237,11 +237,11 @@ func (c *Client) onRedeemingTx(tx *btcutil.Tx, block *btcws.BlockDetails) {
c.enqueueNotification <- RedeemingTx{tx, blk}
}
func (c *Client) onRescanProgress(hash *btcwire.ShaHash, height int32, blkTime time.Time) {
func (c *Client) onRescanProgress(hash *wire.ShaHash, height int32, blkTime time.Time) {
c.enqueueNotification <- &RescanProgress{hash, height, blkTime}
}
func (c *Client) onRescanFinished(hash *btcwire.ShaHash, height int32, blkTime time.Time) {
func (c *Client) onRescanFinished(hash *wire.ShaHash, height int32, blkTime time.Time) {
c.enqueueNotification <- &RescanFinished{hash, height, blkTime}
}

4
config.go
View file

@ -24,15 +24,15 @@ import (
"sort"
"strings"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwire"
flags "github.com/btcsuite/go-flags"
)
const (
defaultCAFilename = "btcd.cert"
defaultConfigFilename = "btcwallet.conf"
defaultBtcNet = btcwire.TestNet3
defaultBtcNet = wire.TestNet3
defaultLogLevel = "info"
defaultLogDirname = "logs"
defaultLogFilename = "btcwallet.log"

24
createtx.go
View file

@ -25,10 +25,10 @@ import (
"github.com/btcsuite/btcd/blockchain"
"github.com/btcsuite/btcd/txscript"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/keystore"
"github.com/btcsuite/btcwallet/txstore"
"github.com/btcsuite/btcwire"
)
const (
@ -163,7 +163,7 @@ func createTx(
changeAddress func(*keystore.BlockStamp) (btcutil.Address, error)) (
*CreatedTx, error) {
msgtx := btcwire.NewMsgTx()
msgtx := wire.NewMsgTx()
minAmount, err := addOutputs(msgtx, outputs)
if err != nil {
return nil, err
@ -184,7 +184,7 @@ func createTx(
}
input, eligible = eligible[0], eligible[1:]
inputs = append(inputs, input)
msgtx.AddTxIn(btcwire.NewTxIn(input.OutPoint(), nil))
msgtx.AddTxIn(wire.NewTxIn(input.OutPoint(), nil))
totalAdded += input.Amount()
}
@ -202,7 +202,7 @@ func createTx(
}
input, eligible = eligible[0], eligible[1:]
inputs = append(inputs, input)
msgtx.AddTxIn(btcwire.NewTxIn(input.OutPoint(), nil))
msgtx.AddTxIn(wire.NewTxIn(input.OutPoint(), nil))
szEst += txInEstimate
totalAdded += input.Amount()
feeEst = minimumFee(feeIncrement, szEst, msgtx.TxOut, inputs, bs.Height)
@ -253,7 +253,7 @@ func createTx(
}
input, eligible = eligible[0], eligible[1:]
inputs = append(inputs, input)
msgtx.AddTxIn(btcwire.NewTxIn(input.OutPoint(), nil))
msgtx.AddTxIn(wire.NewTxIn(input.OutPoint(), nil))
szEst += txInEstimate
totalAdded += input.Amount()
feeEst = minimumFee(feeIncrement, szEst, msgtx.TxOut, inputs, bs.Height)
@ -274,12 +274,12 @@ func createTx(
// addChange adds a new output with the given amount and address, and
// randomizes the index (and returns it) of the newly added output.
func addChange(msgtx *btcwire.MsgTx, change btcutil.Amount, changeAddr btcutil.Address) (int, error) {
func addChange(msgtx *wire.MsgTx, change btcutil.Amount, changeAddr btcutil.Address) (int, error) {
pkScript, err := txscript.PayToAddrScript(changeAddr)
if err != nil {
return 0, fmt.Errorf("cannot create txout script: %s", err)
}
msgtx.AddTxOut(btcwire.NewTxOut(int64(change), pkScript))
msgtx.AddTxOut(wire.NewTxOut(int64(change), pkScript))
// Randomize index of the change output.
rng := badrand.New(badrand.NewSource(time.Now().UnixNano()))
@ -308,7 +308,7 @@ func (w *Wallet) changeAddress(bs *keystore.BlockStamp) (btcutil.Address, error)
// addOutputs adds the given address/amount pairs as outputs to msgtx,
// returning their total amount.
func addOutputs(msgtx *btcwire.MsgTx, pairs map[string]btcutil.Amount) (btcutil.Amount, error) {
func addOutputs(msgtx *wire.MsgTx, pairs map[string]btcutil.Amount) (btcutil.Amount, error) {
var minAmount btcutil.Amount
for addrStr, amt := range pairs {
if amt <= 0 {
@ -325,7 +325,7 @@ func addOutputs(msgtx *btcwire.MsgTx, pairs map[string]btcutil.Amount) (btcutil.
if err != nil {
return minAmount, fmt.Errorf("cannot create txout script: %s", err)
}
txout := btcwire.NewTxOut(int64(amt), pkScript)
txout := wire.NewTxOut(int64(amt), pkScript)
msgtx.AddTxOut(txout)
}
return minAmount, nil
@ -370,7 +370,7 @@ func (w *Wallet) findEligibleOutputs(minconf int, bs *keystore.BlockStamp) ([]tx
// signMsgTx sets the SignatureScript for every item in msgtx.TxIn.
// It must be called every time a msgtx is changed.
// Only P2PKH outputs are supported at this point.
func signMsgTx(msgtx *btcwire.MsgTx, prevOutputs []txstore.Credit, store *keystore.Store) error {
func signMsgTx(msgtx *wire.MsgTx, prevOutputs []txstore.Credit, store *keystore.Store) error {
if len(prevOutputs) != len(msgtx.TxIn) {
return fmt.Errorf(
"Number of prevOutputs (%d) does not match number of tx inputs (%d)",
@ -410,7 +410,7 @@ func signMsgTx(msgtx *btcwire.MsgTx, prevOutputs []txstore.Credit, store *keysto
return nil
}
func validateMsgTx(msgtx *btcwire.MsgTx, prevOutputs []txstore.Credit) error {
func validateMsgTx(msgtx *wire.MsgTx, prevOutputs []txstore.Credit) error {
flags := txscript.ScriptCanonicalSignatures | txscript.ScriptStrictMultiSig
bip16 := time.Now().After(txscript.Bip16Activation)
if bip16 {
@ -434,7 +434,7 @@ func validateMsgTx(msgtx *btcwire.MsgTx, prevOutputs []txstore.Credit) error {
// s less than 1 kilobyte and none of the outputs contain a value
// less than 1 bitcent. Otherwise, the fee will be calculated using
// incr, incrementing the fee for each kilobyte of transaction.
func minimumFee(incr btcutil.Amount, txLen int, outputs []*btcwire.TxOut, prevOutputs []txstore.Credit, height int32) btcutil.Amount {
func minimumFee(incr btcutil.Amount, txLen int, outputs []*wire.TxOut, prevOutputs []txstore.Credit, height int32) btcutil.Amount {
allowFree := false
if !cfg.DisallowFree {
allowFree = allowNoFeeTx(height, prevOutputs, txLen)

6
createtx_test.go
View file

@ -7,10 +7,10 @@ import (
"testing"
"github.com/btcsuite/btcd/txscript"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/keystore"
"github.com/btcsuite/btcwallet/txstore"
"github.com/btcsuite/btcwire"
)
// This is a tx that transfers funds (0.371 BTC) to addresses of known privKeys.
@ -41,7 +41,7 @@ var (
)
func Test_addOutputs(t *testing.T) {
msgtx := btcwire.NewMsgTx()
msgtx := wire.NewMsgTx()
pairs := map[string]btcutil.Amount{outAddr1: 10, outAddr2: 1}
if _, err := addOutputs(msgtx, pairs); err != nil {
t.Fatal(err)
@ -126,7 +126,7 @@ func TestCreateTxInsufficientFundsError(t *testing.T) {
}
// checkOutputsMatch checks that the outputs in the tx match the expected ones.
func checkOutputsMatch(t *testing.T, msgtx *btcwire.MsgTx, expected map[string]btcutil.Amount) {
func checkOutputsMatch(t *testing.T, msgtx *wire.MsgTx, expected map[string]btcutil.Amount) {
// This is a bit convoluted because the index of the change output is randomized.
for addrStr, v := range expected {
addr, err := btcutil.DecodeAddress(addrStr, activeNet.Params)

10
createtx_test_disabled.go
View file

@ -13,9 +13,9 @@ import (
"testing"
"github.com/btcsuite/btcd/txscript"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/tx"
"github.com/btcsuite/btcwire"
)
func init() {
@ -83,14 +83,14 @@ func TestAllowFree(t *testing.T) {
func TestFakeTxs(t *testing.T) {
// First we need a wallet.
w, err := keystore.NewStore("banana wallet", "", []byte("banana"),
btcwire.MainNet, &keystore.BlockStamp{}, 100)
wire.MainNet, &keystore.BlockStamp{}, 100)
if err != nil {
t.Errorf("Can not create encrypted wallet: %s", err)
return
}
a := &Wallet{
Wallet: w,
lockedOutpoints: map[btcwire.OutPoint]struct{}{},
lockedOutpoints: map[wire.OutPoint]struct{}{},
}
w.Unlock([]byte("banana"))
@ -106,10 +106,10 @@ func TestFakeTxs(t *testing.T) {
return
}
copy(utxo.AddrHash[:], addr.ScriptAddress())
ophash := (btcwire.ShaHash)([...]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
ophash := (wire.ShaHash)([...]byte{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, 32})
out := btcwire.NewOutPoint(&ophash, 0)
out := wire.NewOutPoint(&ophash, 0)
utxo.Out = tx.OutPoint(*out)
ss, err := txscript.PayToAddrScript(addr)
if err != nil {

34
keystore/keystore.go
View file

@ -37,11 +37,11 @@ import (
"golang.org/x/crypto/ripemd160"
"github.com/btcsuite/btcd/txscript"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcec"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/rename"
"github.com/btcsuite/btcwire"
)
const (
@ -202,7 +202,7 @@ func chainedPrivKey(privkey, pubkey, chaincode []byte) ([]byte, error) {
}
xorbytes := make([]byte, 32)
chainMod := btcwire.DoubleSha256(pubkey)
chainMod := wire.DoubleSha256(pubkey)
for i := range xorbytes {
xorbytes[i] = chainMod[i] ^ chaincode[i]
}
@ -234,7 +234,7 @@ func chainedPubKey(pubkey, chaincode []byte) ([]byte, error) {
}
xorbytes := make([]byte, 32)
chainMod := btcwire.DoubleSha256(pubkey)
chainMod := wire.DoubleSha256(pubkey)
for i := range xorbytes {
xorbytes[i] = chainMod[i] ^ chaincode[i]
}
@ -487,12 +487,12 @@ func (net *netParams) ReadFrom(r io.Reader) (int64, error) {
return n64, err
}
switch btcwire.BitcoinNet(binary.LittleEndian.Uint32(uint32Bytes)) {
case btcwire.MainNet:
switch wire.BitcoinNet(binary.LittleEndian.Uint32(uint32Bytes)) {
case wire.MainNet:
*net = (netParams)(btcnet.MainNetParams)
case btcwire.TestNet3:
case wire.TestNet3:
*net = (netParams)(btcnet.TestNet3Params)
case btcwire.SimNet:
case wire.SimNet:
*net = (netParams)(btcnet.SimNetParams)
default:
return n64, errors.New("unknown network")
@ -601,7 +601,7 @@ func New(dir string, desc string, passphrase []byte, net *btcnet.Params,
kdfParams: *kdfp,
recent: recentBlocks{
lastHeight: createdAt.Height,
hashes: []*btcwire.ShaHash{
hashes: []*wire.ShaHash{
createdAt.Hash,
},
},
@ -1354,7 +1354,7 @@ func (s *Store) SetSyncedWith(bs *BlockStamp) {
// NOTE: If the hash of the synced block is not known, hash will be nil, and
// must be obtained from elsewhere. This must be explicitly checked before
// dereferencing the pointer.
func (s *Store) SyncedTo() (hash *btcwire.ShaHash, height int32) {
func (s *Store) SyncedTo() (hash *wire.ShaHash, height int32) {
s.mtx.RLock()
defer s.mtx.RUnlock()
@ -1541,7 +1541,7 @@ func (s *Store) ExportWatchingWallet() (*Store, error) {
kgwc := s.keyGenerator.watchingCopy(ws)
ws.keyGenerator = *(kgwc.(*btcAddress))
if len(s.recent.hashes) != 0 {
ws.recent.hashes = make([]*btcwire.ShaHash, 0, len(s.recent.hashes))
ws.recent.hashes = make([]*wire.ShaHash, 0, len(s.recent.hashes))
for _, hash := range s.recent.hashes {
hashCpy := *hash
ws.recent.hashes = append(ws.recent.hashes, &hashCpy)
@ -1796,7 +1796,7 @@ func (af *addrFlags) WriteTo(w io.Writer) (int64, error) {
// recentBlocks holds at most the last 20 seen block hashes as well as
// the block height of the most recently seen block.
type recentBlocks struct {
hashes []*btcwire.ShaHash
hashes []*wire.ShaHash
lastHeight int32
}
@ -1828,14 +1828,14 @@ func (rb *recentBlocks) readFromVersion(v version, r io.Reader) (int64, error) {
}
// Read block hash.
var syncedBlockHash btcwire.ShaHash
var syncedBlockHash wire.ShaHash
n, err = io.ReadFull(r, syncedBlockHash[:])
read += int64(n)
if err != nil {
return read, err
}
rb.hashes = []*btcwire.ShaHash{
rb.hashes = []*wire.ShaHash{
&syncedBlockHash,
}
@ -1879,9 +1879,9 @@ func (rb *recentBlocks) ReadFrom(r io.Reader) (int64, error) {
// Read nBlocks block hashes. Hashes are expected to be in
// order of oldest to newest, but there's no way to check
// that here.
rb.hashes = make([]*btcwire.ShaHash, 0, nBlocks)
rb.hashes = make([]*wire.ShaHash, 0, nBlocks)
for i := uint32(0); i < nBlocks; i++ {
var blockSha btcwire.ShaHash
var blockSha wire.ShaHash
n, err := io.ReadFull(r, blockSha[:])
read += int64(n)
if err != nil {
@ -3040,7 +3040,7 @@ func (sa *scriptAddress) watchingCopy(s *Store) walletAddress {
}
func walletHash(b []byte) uint32 {
sum := btcwire.DoubleSha256(b)
sum := wire.DoubleSha256(b)
return binary.LittleEndian.Uint32(sum)
}
@ -3247,6 +3247,6 @@ func (e *scriptEntry) ReadFrom(r io.Reader) (n int64, err error) {
// used to mark a point in the blockchain that a key store element is
// synced to.
type BlockStamp struct {
Hash *btcwire.ShaHash
Hash *wire.ShaHash
Height int32
}

4
keystore/keystore_test.go
View file

@ -24,10 +24,10 @@ import (
"testing"
"github.com/btcsuite/btcd/txscript"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcec"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwire"
"github.com/davecgh/go-spew/spew"
)
@ -38,7 +38,7 @@ var tstNetParams = &btcnet.MainNetParams
func makeBS(height int32) *BlockStamp {
return &BlockStamp{
Hash: new(btcwire.ShaHash),
Hash: new(wire.ShaHash),
Height: height,
}
}

6
params.go
View file

@ -32,7 +32,7 @@ type params struct {
}
// mainNetParams contains parameters specific running btcwallet and
// btcd on the main network (btcwire.MainNet).
// btcd on the main network (wire.MainNet).
var mainNetParams = params{
Params: &btcnet.MainNetParams,
connect: "localhost:8334",
@ -41,7 +41,7 @@ var mainNetParams = params{
}
// testNet3Params contains parameters specific running btcwallet and
// btcd on the test network (version 3) (btcwire.TestNet3).
// btcd on the test network (version 3) (wire.TestNet3).
var testNet3Params = params{
Params: &btcnet.TestNet3Params,
connect: "localhost:18334",
@ -50,7 +50,7 @@ var testNet3Params = params{
}
// simNetParams contains parameters specific to the simulation test network
// (btcwire.SimNet).
// (wire.SimNet).
var simNetParams = params{
Params: &btcnet.SimNetParams,
connect: "localhost:18556",

8
rescan.go
View file

@ -17,10 +17,10 @@
package main
import (
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/chain"
"github.com/btcsuite/btcwallet/keystore"
"github.com/btcsuite/btcwire"
)
// RescanProgressMsg reports the current progress made by a rescan for a
@ -46,7 +46,7 @@ type RescanFinishedMsg struct {
type RescanJob struct {
InitialSync bool
Addrs []btcutil.Address
OutPoints []*btcwire.OutPoint
OutPoints []*wire.OutPoint
BlockStamp keystore.BlockStamp
err chan error
}
@ -56,7 +56,7 @@ type RescanJob struct {
type rescanBatch struct {
initialSync bool
addrs []btcutil.Address
outpoints []*btcwire.OutPoint
outpoints []*wire.OutPoint
bs keystore.BlockStamp
errChans []chan error
}
@ -301,7 +301,7 @@ func (w *Wallet) RescanActiveAddresses() (err error) {
if err != nil {
return
}
outpoints := make([]*btcwire.OutPoint, len(unspents))
outpoints := make([]*wire.OutPoint, len(unspents))
for i, output := range unspents {
outpoints[i] = output.OutPoint()
}

26
rpcserver.go
View file

@ -38,6 +38,7 @@ import (
"time"
"github.com/btcsuite/btcd/txscript"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcec"
"github.com/btcsuite/btcjson"
"github.com/btcsuite/btcrpcclient"
@ -45,7 +46,6 @@ import (
"github.com/btcsuite/btcwallet/chain"
"github.com/btcsuite/btcwallet/keystore"
"github.com/btcsuite/btcwallet/txstore"
"github.com/btcsuite/btcwire"
"github.com/btcsuite/btcws"
"github.com/btcsuite/websocket"
)
@ -1922,7 +1922,7 @@ func GetReceivedByAddress(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (
func GetTransaction(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (interface{}, error) {
cmd := icmd.(*btcjson.GetTransactionCmd)
txSha, err := btcwire.NewShaHashFromStr(cmd.Txid)
txSha, err := wire.NewShaHashFromStr(cmd.Txid)
if err != nil {
return nil, btcjson.ErrDecodeHexString
}
@ -2184,7 +2184,7 @@ func ListSinceBlock(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (interf
height := int32(-1)
if cmd.BlockHash != "" {
hash, err := btcwire.NewShaHashFromStr(cmd.BlockHash)
hash, err := wire.NewShaHashFromStr(cmd.BlockHash)
if err != nil {
return nil, DeserializationError{err}
}
@ -2328,11 +2328,11 @@ func LockUnspent(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (interface
w.ResetLockedOutpoints()
default:
for _, input := range cmd.Transactions {
txSha, err := btcwire.NewShaHashFromStr(input.Txid)
txSha, err := wire.NewShaHashFromStr(input.Txid)
if err != nil {
return nil, ParseError{err}
}
op := btcwire.OutPoint{Hash: *txSha, Index: input.Vout}
op := wire.OutPoint{Hash: *txSha, Index: input.Vout}
if cmd.Unlock {
w.UnlockOutpoint(op)
} else {
@ -2506,7 +2506,7 @@ func SignMessage(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (interface
fullmsg := "Bitcoin Signed Message:\n" + cmd.Message
sigbytes, err := btcec.SignCompact(btcec.S256(), privKey,
btcwire.DoubleSha256([]byte(fullmsg)), ainfo.Compressed())
wire.DoubleSha256([]byte(fullmsg)), ainfo.Compressed())
if err != nil {
return nil, err
}
@ -2594,7 +2594,7 @@ func SignRawTransaction(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (in
if err != nil {
return nil, btcjson.ErrDecodeHexString
}
msgTx := btcwire.NewMsgTx()
msgTx := wire.NewMsgTx()
err = msgTx.Deserialize(bytes.NewBuffer(serializedTx))
if err != nil {
e := errors.New("TX decode failed")
@ -2604,10 +2604,10 @@ func SignRawTransaction(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (in
// First we add the stuff we have been given.
// TODO(oga) really we probably should look these up with btcd anyway
// to make sure that they match the blockchain if present.
inputs := make(map[btcwire.OutPoint][]byte)
inputs := make(map[wire.OutPoint][]byte)
scripts := make(map[string][]byte)
for _, rti := range cmd.Inputs {
inputSha, err := btcwire.NewShaHashFromStr(rti.Txid)
inputSha, err := wire.NewShaHashFromStr(rti.Txid)
if err != nil {
return nil, DeserializationError{err}
}
@ -2636,7 +2636,7 @@ func SignRawTransaction(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (in
}
scripts[addr.String()] = redeemScript
}
inputs[btcwire.OutPoint{
inputs[wire.OutPoint{
Hash: *inputSha,
Index: rti.Vout,
}] = script
@ -2646,7 +2646,7 @@ func SignRawTransaction(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (in
// querying btcd with getrawtransaction. We queue up a bunch of async
// requests and will wait for replies after we have checked the rest of
// the arguments.
requested := make(map[btcwire.ShaHash]*pendingTx)
requested := make(map[wire.ShaHash]*pendingTx)
for _, txIn := range msgTx.TxIn {
// Did we get this txin from the arguments?
if _, ok := inputs[txIn.PreviousOutPoint]; ok {
@ -2740,7 +2740,7 @@ func SignRawTransaction(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (in
return nil, InvalidParameterError{e}
}
inputs[btcwire.OutPoint{
inputs[wire.OutPoint{
Hash: txid,
Index: input,
}] = tx.MsgTx().TxOut[input].PkScript
@ -2933,7 +2933,7 @@ func VerifyMessage(w *Wallet, chainSvr *chain.Client, icmd btcjson.Cmd) (interfa
// Validate the signature - this just shows that it was valid at all.
// we will compare it with the key next.
pk, wasCompressed, err := btcec.RecoverCompact(btcec.S256(), sig,
btcwire.DoubleSha256([]byte("Bitcoin Signed Message:\n"+
wire.DoubleSha256([]byte("Bitcoin Signed Message:\n"+
cmd.Message)))
if err != nil {
return nil, err

2
txstore/fixedIO_test.go
View file

@ -1,4 +1,4 @@
// copied from btcwire
// copied from wire
// Copyright (c) 2013-2014 Conformal Systems LLC.
// Use of this source code is governed by an ISC

22
txstore/serialization.go
View file

@ -27,9 +27,9 @@ import (
"path/filepath"
"time"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/rename"
"github.com/btcsuite/btcwire"
)
// filename is the name of the file typically used to save a transaction
@ -125,7 +125,7 @@ func (s *Store) ReadFrom(r io.Reader) (int64, error) {
continue
}
if cred.spentBy == nil {
op := btcwire.OutPoint{
op := wire.OutPoint{
Hash: *tx.tx.Sha(),
Index: uint32(outputIdx),
}
@ -419,7 +419,7 @@ func (t *txRecord) ReadFrom(r io.Reader) (int64, error) {
}
// Create and save the btcutil.Tx of the read MsgTx and set its index.
tx := btcutil.NewTx((*btcwire.MsgTx)(msgTx))
tx := btcutil.NewTx((*wire.MsgTx)(msgTx))
tx.SetIndex(txIndex)
t.tx = tx
@ -749,20 +749,20 @@ func (t *txRecord) WriteTo(w io.Writer) (int64, error) {
return n64, nil
}
type msgTx btcwire.MsgTx
type msgTx wire.MsgTx
func (tx *msgTx) ReadFrom(r io.Reader) (int64, error) {
// Read from a TeeReader to return the number of read bytes.
buf := bytes.Buffer{}
tr := io.TeeReader(r, &buf)
if err := (*btcwire.MsgTx)(tx).Deserialize(tr); err != nil {
if err := (*wire.MsgTx)(tx).Deserialize(tr); err != nil {
if buf.Len() != 0 && err == io.EOF {
err = io.ErrUnexpectedEOF
}
return int64(buf.Len()), err
}
return int64((*btcwire.MsgTx)(tx).SerializeSize()), nil
return int64((*wire.MsgTx)(tx).SerializeSize()), nil
}
func (tx *msgTx) WriteTo(w io.Writer) (int64, error) {
@ -771,7 +771,7 @@ func (tx *msgTx) WriteTo(w io.Writer) (int64, error) {
// bytes.Buffer never fails except for OOM panics, so check and panic
// on any unexpected non-nil returned errors.
buf := bytes.Buffer{}
if err := (*btcwire.MsgTx)(tx).Serialize(&buf); err != nil {
if err := (*wire.MsgTx)(tx).Serialize(&buf); err != nil {
panic(err)
}
return io.Copy(w, &buf)
@ -920,7 +920,7 @@ func (u *unconfirmedStore) ReadFrom(r io.Reader) (int64, error) {
spentBlockOutPointCount := byteOrder.Uint32(uint32Bytes)
for i := uint32(0); i < spentBlockOutPointCount; i++ {
// Read outpoint hash and index (uint32).
op := btcwire.OutPoint{}
op := wire.OutPoint{}
n, err := io.ReadFull(r, op.Hash[:])
n64 += int64(n)
if err != nil {
@ -953,7 +953,7 @@ func (u *unconfirmedStore) ReadFrom(r io.Reader) (int64, error) {
// Read transaction record hash and check that it was previously
// read into the txs map. Use full record as the map value.
var txHash btcwire.ShaHash
var txHash wire.ShaHash
n, err = io.ReadFull(r, txHash[:])
n64 += int64(n)
if err != nil {
@ -987,7 +987,7 @@ func (u *unconfirmedStore) ReadFrom(r io.Reader) (int64, error) {
spentUnconfirmedCount := byteOrder.Uint32(uint32Bytes)
for i := uint32(0); i < spentUnconfirmedCount; i++ {
// Read outpoint hash and index (uint32).
op := btcwire.OutPoint{}
op := wire.OutPoint{}
n, err := io.ReadFull(r, op.Hash[:])
n64 += int64(n)
if err != nil {
@ -1008,7 +1008,7 @@ func (u *unconfirmedStore) ReadFrom(r io.Reader) (int64, error) {
// Read transaction record hash and check that it was previously
// read into the txs map. Use full record as the map value.
var txHash btcwire.ShaHash
var txHash wire.ShaHash
n, err = io.ReadFull(r, txHash[:])
n64 += int64(n)
if err != nil {

44
txstore/tx.go
View file

@ -26,9 +26,9 @@ import (
"github.com/btcsuite/btcd/blockchain"
"github.com/btcsuite/btcd/txscript"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwire"
)
var (
@ -128,7 +128,7 @@ type TxRecord struct {
// Block holds details about a block that contains wallet transactions.
type Block struct {
Hash btcwire.ShaHash
Hash wire.ShaHash
Time time.Time
Height int32
}
@ -172,7 +172,7 @@ type Store struct {
blocks []*blockTxCollection
blockIndexes map[int32]uint32
unspent map[btcwire.OutPoint]BlockTxKey
unspent map[wire.OutPoint]BlockTxKey
// unconfirmed holds a collection of wallet transactions that have not
// been mined into a block yet.
@ -211,23 +211,23 @@ type blockTxCollection struct {
type unconfirmedStore struct {
// txs contains all unconfirmed transactions, mapping from their
// transaction hash to the records.
txs map[btcwire.ShaHash]*txRecord
txs map[wire.ShaHash]*txRecord
// spentBlockOutPoints maps from spent outputs from mined transaction
// to the unconfirmed transaction which spends it. An additional
// map is included to lookup the output key by its outpoint.
spentBlockOutPoints map[BlockOutputKey]*txRecord
spentBlockOutPointKeys map[btcwire.OutPoint]BlockOutputKey
spentBlockOutPointKeys map[wire.OutPoint]BlockOutputKey
// spentUnconfirmed maps from an unconfirmed outpoint to the unconfirmed
// transaction which spends it.
spentUnconfirmed map[btcwire.OutPoint]*txRecord
spentUnconfirmed map[wire.OutPoint]*txRecord
// previousOutpoints maps all previous outputs to the transaction record
// of the unconfirmed transaction which spends it. This is primarly
// designed to assist with double spend detection without iterating
// through each value of the txs map.
previousOutpoints map[btcwire.OutPoint]*txRecord
previousOutpoints map[wire.OutPoint]*txRecord
}
// BlockTxKey is a lookup key for a single mined transaction in the store.
@ -280,13 +280,13 @@ func New(dir string) *Store {
dir: dir,
file: filename,
blockIndexes: map[int32]uint32{},
unspent: map[btcwire.OutPoint]BlockTxKey{},
unspent: map[wire.OutPoint]BlockTxKey{},
unconfirmed: unconfirmedStore{
txs: map[btcwire.ShaHash]*txRecord{},
txs: map[wire.ShaHash]*txRecord{},
spentBlockOutPoints: map[BlockOutputKey]*txRecord{},
spentBlockOutPointKeys: map[btcwire.OutPoint]BlockOutputKey{},
spentUnconfirmed: map[btcwire.OutPoint]*txRecord{},
previousOutpoints: map[btcwire.OutPoint]*txRecord{},
spentBlockOutPointKeys: map[wire.OutPoint]BlockOutputKey{},
spentUnconfirmed: map[wire.OutPoint]*txRecord{},
previousOutpoints: map[wire.OutPoint]*txRecord{},
},
notificationLock: new(sync.Mutex),
}
@ -482,7 +482,7 @@ func (s *Store) moveMinedTx(r *txRecord, block *Block) error {
// If the credit is not spent, modify the store's unspent bookkeeping
// maps to include the credit and increment the amount deltas by the
// credit's value.
op := btcwire.OutPoint{Hash: *r.Tx().Sha()}
op := wire.OutPoint{Hash: *r.Tx().Sha()}
for i, credit := range r.credits {
if credit == nil {
continue
@ -666,7 +666,7 @@ func (s *Store) findPreviousCredits(tx *btcutil.Tx) ([]Credit, error) {
creditChans := make([]chan createdCredit, len(inputs))
for i, txIn := range inputs {
creditChans[i] = make(chan createdCredit, 1)
go func(i int, op btcwire.OutPoint) {
go func(i int, op wire.OutPoint) {
key, ok := s.unspent[op]
if !ok {
// Does this input spend an unconfirmed output?
@ -812,7 +812,7 @@ func (t *TxRecord) AddCredit(index uint32, change bool) (Credit, error) {
}
// New outputs are added unspent.
op := btcwire.OutPoint{Hash: *t.tx.Sha(), Index: index}
op := wire.OutPoint{Hash: *t.tx.Sha(), Index: index}
t.s.unspent[op] = t.BlockTxKey
switch t.tx.Index() {
case 0: // Coinbase
@ -875,7 +875,7 @@ func (s *Store) Rollback(height int32) error {
continue
}
op := btcwire.OutPoint{
op := wire.OutPoint{
Hash: *r.Tx().Sha(),
Index: uint32(outIdx),
}
@ -943,7 +943,7 @@ func (s *Store) Rollback(height int32) error {
if err != nil {
return err
}
op := btcwire.OutPoint{
op := wire.OutPoint{
Hash: *rr.Tx().Sha(),
Index: prev.OutputIndex,
}
@ -1025,7 +1025,7 @@ func (s *Store) removeConflict(r *txRecord) error {
if credit == nil || credit.spentBy == nil {
continue
}
op := btcwire.NewOutPoint(r.Tx().Sha(), uint32(i))
op := wire.NewOutPoint(r.Tx().Sha(), uint32(i))
nextSpender, ok := u.spentUnconfirmed[*op]
if !ok {
return ErrInconsistentStore
@ -1484,15 +1484,15 @@ func (c Credit) amount() btcutil.Amount {
// OutPoint returns the outpoint needed to include in a transaction input
// to spend this output.
func (c Credit) OutPoint() *btcwire.OutPoint {
func (c Credit) OutPoint() *wire.OutPoint {
c.s.mtx.RLock()
defer c.s.mtx.RUnlock()
return c.outPoint()
}
func (c Credit) outPoint() *btcwire.OutPoint {
return btcwire.NewOutPoint(c.Tx().Sha(), c.OutputIndex)
func (c Credit) outPoint() *wire.OutPoint {
return wire.NewOutPoint(c.Tx().Sha(), c.OutputIndex)
}
// outputKey creates and returns the block lookup key for this credit.
@ -1512,7 +1512,7 @@ func (c Credit) Spent() bool {
}
// TxOut returns the transaction output which this credit references.
func (c Credit) TxOut() *btcwire.TxOut {
func (c Credit) TxOut() *wire.TxOut {
c.s.mtx.RLock()
defer c.s.mtx.RUnlock()

120
txstore/tx_test.go
View file

@ -20,10 +20,10 @@ import (
"testing"
"time"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil"
. "github.com/btcsuite/btcwallet/txstore"
"github.com/btcsuite/btcwire"
)
// Received transaction output for mainnet outpoint
@ -31,7 +31,7 @@ import (
var (
TstRecvSerializedTx, _ = hex.DecodeString("010000000114d9ff358894c486b4ae11c2a8cf7851b1df64c53d2e511278eff17c22fb7373000000008c493046022100995447baec31ee9f6d4ec0e05cb2a44f6b817a99d5f6de167d1c75354a946410022100c9ffc23b64d770b0e01e7ff4d25fbc2f1ca8091053078a247905c39fce3760b601410458b8e267add3c1e374cf40f1de02b59213a82e1d84c2b94096e22e2f09387009c96debe1d0bcb2356ffdcf65d2a83d4b34e72c62eccd8490dbf2110167783b2bffffffff0280969800000000001976a914479ed307831d0ac19ebc5f63de7d5f1a430ddb9d88ac38bfaa00000000001976a914dadf9e3484f28b385ddeaa6c575c0c0d18e9788a88ac00000000")
TstRecvTx, _ = btcutil.NewTxFromBytes(TstRecvSerializedTx)
TstRecvTxSpendingTxBlockHash, _ = btcwire.NewShaHashFromStr("00000000000000017188b968a371bab95aa43522665353b646e41865abae02a4")
TstRecvTxSpendingTxBlockHash, _ = wire.NewShaHashFromStr("00000000000000017188b968a371bab95aa43522665353b646e41865abae02a4")
TstRecvAmt = int64(10000000)
TstRecvIndex = 684
TstRecvTxBlockDetails = &Block{
@ -46,7 +46,7 @@ var (
TstSpendingSerializedTx, _ = hex.DecodeString("0100000003ad3fba7ebd67c09baa9538898e10d6726dcb8eadb006be0c7388c8e46d69d361000000006b4830450220702c4fbde5532575fed44f8d6e8c3432a2a9bd8cff2f966c3a79b2245a7c88db02210095d6505a57e350720cb52b89a9b56243c15ddfcea0596aedc1ba55d9fb7d5aa0012103cccb5c48a699d3efcca6dae277fee6b82e0229ed754b742659c3acdfed2651f9ffffffffdbd36173f5610e34de5c00ed092174603761595d90190f790e79cda3e5b45bc2010000006b483045022000fa20735e5875e64d05bed43d81b867f3bd8745008d3ff4331ef1617eac7c44022100ad82261fc57faac67fc482a37b6bf18158da0971e300abf5fe2f9fd39e107f58012102d4e1caf3e022757512c204bf09ff56a9981df483aba3c74bb60d3612077c9206ffffffff65536c9d964b6f89b8ef17e83c6666641bc495cb27bab60052f76cd4556ccd0d040000006a473044022068e3886e0299ffa69a1c3ee40f8b6700f5f6d463a9cf9dbf22c055a131fc4abc02202b58957fe19ff1be7a84c458d08016c53fbddec7184ac5e633f2b282ae3420ae012103b4e411b81d32a69fb81178a8ea1abaa12f613336923ee920ffbb1b313af1f4d2ffffffff02ab233200000000001976a91418808b2fbd8d2c6d022aed5cd61f0ce6c0a4cbb688ac4741f011000000001976a914f081088a300c80ce36b717a9914ab5ec8a7d283988ac00000000")
TstSpendingTx, _ = btcutil.NewTxFromBytes(TstSpendingSerializedTx)
TstSpendingTxBlockHeight = int32(279143)
TstSignedTxBlockHash, _ = btcwire.NewShaHashFromStr("00000000000000017188b968a371bab95aa43522665353b646e41865abae02a4")
TstSignedTxBlockHash, _ = wire.NewShaHashFromStr("00000000000000017188b968a371bab95aa43522665353b646e41865abae02a4")
TstSignedTxIndex = 123
TstSignedTxBlockDetails = &Block{
Height: TstSpendingTxBlockHeight,
@ -68,11 +68,11 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
// 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 := wire.NewMsgTx()
spendingTxIn := wire.NewTxIn(wire.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})
spendingTxOut1 := wire.NewTxOut(1e7, []byte{5, 6, 7, 8, 9})
spendingTxOut2 := wire.NewTxOut(9e7, []byte{10, 11, 12, 13, 14})
spendingTx.AddTxOut(spendingTxOut1)
spendingTx.AddTxOut(spendingTxOut2)
TstSpendingTx := btcutil.NewTx(spendingTx)
@ -82,8 +82,8 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
name string
f func(*Store) (*Store, error)
bal, unc btcutil.Amount
unspents map[btcwire.OutPoint]struct{}
unmined map[btcwire.ShaHash]struct{}
unspents map[wire.OutPoint]struct{}
unmined map[wire.ShaHash]struct{}
}{
{
name: "new store",
@ -92,8 +92,8 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{},
unmined: map[btcwire.ShaHash]struct{}{},
unspents: map[wire.OutPoint]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "txout insert",
@ -117,10 +117,10 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: btcutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstRecvTx.Sha(), 0): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "insert duplicate unconfirmed",
@ -143,10 +143,10 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: btcutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstRecvTx.Sha(), 0): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "confirmed txout insert",
@ -170,10 +170,10 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: btcutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstRecvTx.Sha(), 0): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "insert duplicate confirmed",
@ -197,10 +197,10 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: btcutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstRecvTx.Sha(), 0): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "rollback confirmed credit",
@ -213,10 +213,10 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: btcutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstRecvTx.Sha(), 0): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "insert confirmed double spend",
@ -241,10 +241,10 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: btcutil.Amount(TstDoubleSpendTx.MsgTx().TxOut[0].Value),
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstDoubleSpendTx.Sha(), 0): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstDoubleSpendTx.Sha(), 0): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "insert unconfirmed debit",
@ -272,8 +272,8 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{},
unmined: map[btcwire.ShaHash]struct{}{
unspents: map[wire.OutPoint]struct{}{},
unmined: map[wire.ShaHash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
@ -303,8 +303,8 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{},
unmined: map[btcwire.ShaHash]struct{}{
unspents: map[wire.OutPoint]struct{}{},
unmined: map[wire.ShaHash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
@ -329,10 +329,10 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: btcutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value),
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
},
unmined: map[btcwire.ShaHash]struct{}{
unmined: map[wire.ShaHash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
@ -357,11 +357,11 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: btcutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*wire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
},
unmined: map[btcwire.ShaHash]struct{}{
unmined: map[wire.ShaHash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
@ -382,11 +382,11 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: btcutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*wire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "rollback after spending tx",
@ -399,11 +399,11 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: btcutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*wire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
{
name: "rollback spending tx block",
@ -416,11 +416,11 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: btcutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*wire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
},
unmined: map[btcwire.ShaHash]struct{}{
unmined: map[wire.ShaHash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
@ -435,11 +435,11 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: 0,
unc: btcutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*btcwire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstSpendingTx.Sha(), 0): {},
*wire.NewOutPoint(TstSpendingTx.Sha(), 1): {},
},
unmined: map[btcwire.ShaHash]struct{}{
unmined: map[wire.ShaHash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
@ -465,10 +465,10 @@ func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
},
bal: btcutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unc: 0,
unspents: map[btcwire.OutPoint]struct{}{
*btcwire.NewOutPoint(TstRecvTx.Sha(), 0): {},
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstRecvTx.Sha(), 0): {},
},
unmined: map[btcwire.ShaHash]struct{}{},
unmined: map[wire.ShaHash]struct{}{},
},
}
@ -586,7 +586,7 @@ func TestFindingSpentCredits(t *testing.T) {
if err != nil {
t.Fatal(err)
}
op := btcwire.NewOutPoint(TstSpendingTx.Sha(), 0)
op := wire.NewOutPoint(TstSpendingTx.Sha(), 0)
if *unspents[0].OutPoint() != *op {
t.Fatal("unspent outpoint doesn't match expected")
}

8
waddrmgr/db.go
View file

@ -22,8 +22,8 @@ import (
"fmt"
"time"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcwallet/walletdb"
"github.com/btcsuite/btcwire"
"github.com/btcsuite/fastsha256"
)
@ -1116,7 +1116,7 @@ func putStartBlock(tx walletdb.Tx, bs *BlockStamp) error {
// fetchRecentBlocks returns the height of the most recent block height and
// hashes of the most recent blocks.
func fetchRecentBlocks(tx walletdb.Tx) (int32, []btcwire.ShaHash, error) {
func fetchRecentBlocks(tx walletdb.Tx) (int32, []wire.ShaHash, error) {
bucket := tx.RootBucket().Bucket(syncBucketName)
// The serialized recent blocks format is:
@ -1135,7 +1135,7 @@ func fetchRecentBlocks(tx walletdb.Tx) (int32, []btcwire.ShaHash, error) {
recentHeight := int32(binary.LittleEndian.Uint32(buf[0:4]))
numHashes := binary.LittleEndian.Uint32(buf[4:8])
recentHashes := make([]btcwire.ShaHash, numHashes)
recentHashes := make([]wire.ShaHash, numHashes)
offset := 8
for i := uint32(0); i < numHashes; i++ {
copy(recentHashes[i][:], buf[offset:offset+32])
@ -1146,7 +1146,7 @@ func fetchRecentBlocks(tx walletdb.Tx) (int32, []btcwire.ShaHash, error) {
}
// putRecentBlocks stores the provided start block stamp to the database.
func putRecentBlocks(tx walletdb.Tx, recentHeight int32, recentHashes []btcwire.ShaHash) error {
func putRecentBlocks(tx walletdb.Tx, recentHeight int32, recentHashes []wire.ShaHash) error {
bucket := tx.RootBucket().Bucket(syncBucketName)
// The serialized recent blocks format is:

6
waddrmgr/manager.go
View file

@ -22,13 +22,13 @@ import (
"fmt"
"sync"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcec"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcutil/hdkeychain"
"github.com/btcsuite/btcwallet/snacl"
"github.com/btcsuite/btcwallet/walletdb"
"github.com/btcsuite/btcwire"
)
const (
@ -1724,7 +1724,7 @@ func loadManager(namespace walletdb.Namespace, pubPassphrase []byte, net *btcnet
var cryptoKeyPubEnc, cryptoKeyPrivEnc, cryptoKeyScriptEnc []byte
var syncedTo, startBlock *BlockStamp
var recentHeight int32
var recentHashes []btcwire.ShaHash
var recentHashes []wire.ShaHash
err := namespace.View(func(tx walletdb.Tx) error {
// Load whether or not the manager is watching-only from the db.
var err error
@ -2012,7 +2012,7 @@ func Create(namespace walletdb.Namespace, seed, pubPassphrase, privPassphrase []
createdAt := &BlockStamp{Hash: *net.GenesisHash, Height: 0}
// Create the initial sync state.
recentHashes := []btcwire.ShaHash{createdAt.Hash}
recentHashes := []wire.ShaHash{createdAt.Hash}
recentHeight := createdAt.Height
syncInfo := newSyncState(createdAt, createdAt, recentHeight, recentHashes)

14
waddrmgr/manager_test.go
View file

@ -23,19 +23,19 @@ import (
"reflect"
"testing"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/waddrmgr"
"github.com/btcsuite/btcwallet/walletdb"
"github.com/btcsuite/btcwire"
)
// newShaHash converts the passed big-endian hex string into a btcwire.ShaHash.
// It only differs from the one available in btcwire in that it panics on an
// newShaHash converts the passed big-endian hex string into a wire.ShaHash.
// It only differs from the one available in wire in that it panics on an
// error since it will only (and must only) be called with hard-coded, and
// therefore known good, hashes.
func newShaHash(hexStr string) *btcwire.ShaHash {
sha, err := btcwire.NewShaHashFromStr(hexStr)
func newShaHash(hexStr string) *wire.ShaHash {
sha, err := wire.NewShaHashFromStr(hexStr)
if err != nil {
panic(err)
}
@ -1207,7 +1207,7 @@ func testWatchingOnly(tc *testContext) bool {
func testSync(tc *testContext) bool {
tests := []struct {
name string
hash *btcwire.ShaHash
hash *wire.ShaHash
}{
{
name: "Block 1",
@ -1328,7 +1328,7 @@ func testSync(tc *testContext) bool {
iter := tc.manager.NewIterateRecentBlocks()
for cont := iter != nil; cont; cont = iter.Prev() {
wantHeight := int32(i) - int32(j) + 1
var wantHash *btcwire.ShaHash
var wantHash *wire.ShaHash
if wantHeight == 0 {
wantHash = btcnet.MainNetParams.GenesisHash
} else {

8
waddrmgr/sync.go
View file

@ -19,8 +19,8 @@ package waddrmgr
import (
"sync"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcwallet/walletdb"
"github.com/btcsuite/btcwire"
)
const (
@ -34,7 +34,7 @@ const (
// synced to.
type BlockStamp struct {
Height int32
Hash btcwire.ShaHash
Hash wire.ShaHash
}
// syncState houses the sync state of the manager. It consists of the recently
@ -53,7 +53,7 @@ type syncState struct {
recentHeight int32
// recentHashes is a list of the last several seen block hashes.
recentHashes []btcwire.ShaHash
recentHashes []wire.ShaHash
}
// iter returns a BlockIterator that can be used to iterate over the recently
@ -72,7 +72,7 @@ func (s *syncState) iter(mtx *sync.RWMutex) *BlockIterator {
// newSyncState returns a new sync state with the provided parameters.
func newSyncState(startBlock, syncedTo *BlockStamp, recentHeight int32,
recentHashes []btcwire.ShaHash) *syncState {
recentHashes []wire.ShaHash) *syncState {
return &syncState{
startBlock: *startBlock,

20
wallet.go
View file

@ -27,13 +27,13 @@ import (
"time"
"github.com/btcsuite/btcd/blockchain"
"github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcjson"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil"
"github.com/btcsuite/btcwallet/chain"
"github.com/btcsuite/btcwallet/keystore"
"github.com/btcsuite/btcwallet/txstore"
"github.com/btcsuite/btcwire"
)
var (
@ -54,7 +54,7 @@ func networkDir(net *btcnet.Params) string {
// paramaters will likely be switched to being named "testnet3" in the
// future. This is done to future proof that change, and an upgrade
// plan to move the testnet3 data directory can be worked out later.
if net.Net == btcwire.TestNet3 {
if net.Net == wire.TestNet3 {
netname = "testnet"
}
@ -73,7 +73,7 @@ type Wallet struct {
chainSvrLock sync.Locker
chainSynced chan struct{} // closed when synced
lockedOutpoints map[btcwire.OutPoint]struct{}
lockedOutpoints map[wire.OutPoint]struct{}
FeeIncrement btcutil.Amount
// Channels for rescan processing. Requests are added and merged with
@ -117,7 +117,7 @@ func newWallet(keys *keystore.Store, txs *txstore.Store) *Wallet {
TxStore: txs,
chainSvrLock: new(sync.Mutex),
chainSynced: make(chan struct{}),
lockedOutpoints: map[btcwire.OutPoint]struct{}{},
lockedOutpoints: map[wire.OutPoint]struct{}{},
FeeIncrement: defaultFeeIncrement,
rescanAddJob: make(chan *RescanJob),
rescanBatch: make(chan *rescanBatch),
@ -1110,27 +1110,27 @@ func (w *Wallet) exportBase64() (map[string]string, error) {
// LockedOutpoint returns whether an outpoint has been marked as locked and
// should not be used as an input for created transactions.
func (w *Wallet) LockedOutpoint(op btcwire.OutPoint) bool {
func (w *Wallet) LockedOutpoint(op wire.OutPoint) bool {
_, locked := w.lockedOutpoints[op]
return locked
}
// LockOutpoint marks an outpoint as locked, that is, it should not be used as
// an input for newly created transactions.
func (w *Wallet) LockOutpoint(op btcwire.OutPoint) {
func (w *Wallet) LockOutpoint(op wire.OutPoint) {
w.lockedOutpoints[op] = struct{}{}
}
// UnlockOutpoint marks an outpoint as unlocked, that is, it may be used as an
// input for newly created transactions.
func (w *Wallet) UnlockOutpoint(op btcwire.OutPoint) {
func (w *Wallet) UnlockOutpoint(op wire.OutPoint) {
delete(w.lockedOutpoints, op)
}
// ResetLockedOutpoints resets the set of locked outpoints so all may be used
// as inputs for new transactions.
func (w *Wallet) ResetLockedOutpoints() {
w.lockedOutpoints = map[btcwire.OutPoint]struct{}{}
w.lockedOutpoints = map[wire.OutPoint]struct{}{}
}
// LockedOutpoints returns a slice of currently locked outpoints. This is
@ -1310,7 +1310,7 @@ func (w *Wallet) RecoverAddresses(n int) error {
// ReqSpentUtxoNtfns sends a message to btcd to request updates for when
// a stored UTXO has been spent.
func (w *Wallet) ReqSpentUtxoNtfns(credits []txstore.Credit) {
ops := make([]*btcwire.OutPoint, len(credits))
ops := make([]*wire.OutPoint, len(credits))
for i, c := range credits {
op := c.OutPoint()
log.Debugf("Requesting spent UTXO notifications for Outpoint "+
@ -1387,7 +1387,7 @@ func (w *Wallet) TotalReceivedForAddr(addr btcutil.Address, confirms int) (btcut
// TxRecord iterates through all transaction records saved in the store,
// returning the first with an equivalent transaction hash.
func (w *Wallet) TxRecord(txSha *btcwire.ShaHash) (r *txstore.TxRecord, ok bool) {
func (w *Wallet) TxRecord(txSha *wire.ShaHash) (r *txstore.TxRecord, ok bool) {
for _, r = range w.TxStore.Records() {
if *r.Tx().Sha() == *txSha {
return r, true