LBRYCommunity/lbcutil
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update btcnet path import paths to new location.

Browse source
This commit is contained in:
Dave Collins 2015-02-05 22:04:58 -06:00
parent 56fe089f4e
commit 1324fa1fad
9 changed files with 106 additions and 106 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
address.go
View file

@ -10,8 +10,8 @@ import (
"golang.org/x/crypto/ripemd160" "golang.org/x/crypto/ripemd160"
"github.com/btcsuite/btcd/chaincfg"
"github.com/btcsuite/btcec" "github.com/btcsuite/btcec"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil/base58" "github.com/btcsuite/btcutil/base58"
) )
@ -23,7 +23,7 @@ var (
// ErrUnknownAddressType describes an error where an address can not // ErrUnknownAddressType describes an error where an address can not
// decoded as a specific address type due to the string encoding // decoded as a specific address type due to the string encoding
// begining with an identifier byte unknown to any standard or // begining with an identifier byte unknown to any standard or
// registered (via btcnet.Register) network. // registered (via chaincfg.Register) network.
ErrUnknownAddressType = errors.New("unknown address type") ErrUnknownAddressType = errors.New("unknown address type")
// ErrAddressCollision describes an error where an address can not // ErrAddressCollision describes an error where an address can not
@ -72,7 +72,7 @@ type Address interface {
// IsForNet returns whether or not the address is associated with the // IsForNet returns whether or not the address is associated with the
// passed bitcoin network. // passed bitcoin network.
IsForNet(*btcnet.Params) bool IsForNet(*chaincfg.Params) bool
} }
// DecodeAddress decodes the string encoding of an address and returns // DecodeAddress decodes the string encoding of an address and returns
@ -81,7 +81,7 @@ type Address interface {
// The bitcoin network the address is associated with is extracted if possible. // The bitcoin network the address is associated with is extracted if possible.
// When the address does not encode the network, such as in the case of a raw // When the address does not encode the network, such as in the case of a raw
// public key, the address will be associated with the passed defaultNet. // public key, the address will be associated with the passed defaultNet.
func DecodeAddress(addr string, defaultNet *btcnet.Params) (Address, error) { func DecodeAddress(addr string, defaultNet *chaincfg.Params) (Address, error) {
// Serialized public keys are either 65 bytes (130 hex chars) if // Serialized public keys are either 65 bytes (130 hex chars) if
// uncompressed/hybrid or 33 bytes (66 hex chars) if compressed. // uncompressed/hybrid or 33 bytes (66 hex chars) if compressed.
if len(addr) == 130 || len(addr) == 66 { if len(addr) == 130 || len(addr) == 66 {
@ -102,8 +102,8 @@ func DecodeAddress(addr string, defaultNet *btcnet.Params) (Address, error) {
} }
switch len(decoded) { switch len(decoded) {
case ripemd160.Size: // P2PKH or P2SH case ripemd160.Size: // P2PKH or P2SH
isP2PKH := btcnet.IsPubKeyHashAddrID(netID) isP2PKH := chaincfg.IsPubKeyHashAddrID(netID)
isP2SH := btcnet.IsScriptHashAddrID(netID) isP2SH := chaincfg.IsScriptHashAddrID(netID)
switch hash160 := decoded; { switch hash160 := decoded; {
case isP2PKH && isP2SH: case isP2PKH && isP2SH:
return nil, ErrAddressCollision return nil, ErrAddressCollision
@ -127,9 +127,9 @@ type AddressPubKeyHash struct {
netID byte netID byte
} }
// NewAddressPubKeyHash returns a new AddressPubKeyHash. pkHash must // NewAddressPubKeyHash returns a new AddressPubKeyHash. pkHash mustbe 20
// be 20 bytes. // bytes.
func NewAddressPubKeyHash(pkHash []byte, net *btcnet.Params) (*AddressPubKeyHash, error) { func NewAddressPubKeyHash(pkHash []byte, net *chaincfg.Params) (*AddressPubKeyHash, error) {
return newAddressPubKeyHash(pkHash, net.PubKeyHashAddrID) return newAddressPubKeyHash(pkHash, net.PubKeyHashAddrID)
} }
@ -163,7 +163,7 @@ func (a *AddressPubKeyHash) ScriptAddress() []byte {
// IsForNet returns whether or not the pay-to-pubkey-hash address is associated // IsForNet returns whether or not the pay-to-pubkey-hash address is associated
// with the passed bitcoin network. // with the passed bitcoin network.
func (a *AddressPubKeyHash) IsForNet(net *btcnet.Params) bool { func (a *AddressPubKeyHash) IsForNet(net *chaincfg.Params) bool {
return a.netID == net.PubKeyHashAddrID return a.netID == net.PubKeyHashAddrID
} }
@ -189,14 +189,14 @@ type AddressScriptHash struct {
} }
// NewAddressScriptHash returns a new AddressScriptHash. // NewAddressScriptHash returns a new AddressScriptHash.
func NewAddressScriptHash(serializedScript []byte, net *btcnet.Params) (*AddressScriptHash, error) { func NewAddressScriptHash(serializedScript []byte, net *chaincfg.Params) (*AddressScriptHash, error) {
scriptHash := Hash160(serializedScript) scriptHash := Hash160(serializedScript)
return newAddressScriptHashFromHash(scriptHash, net.ScriptHashAddrID) return newAddressScriptHashFromHash(scriptHash, net.ScriptHashAddrID)
} }
// NewAddressScriptHashFromHash returns a new AddressScriptHash. scriptHash // NewAddressScriptHashFromHash returns a new AddressScriptHash. scriptHash
// must be 20 bytes. // must be 20 bytes.
func NewAddressScriptHashFromHash(scriptHash []byte, net *btcnet.Params) (*AddressScriptHash, error) { func NewAddressScriptHashFromHash(scriptHash []byte, net *chaincfg.Params) (*AddressScriptHash, error) {
return newAddressScriptHashFromHash(scriptHash, net.ScriptHashAddrID) return newAddressScriptHashFromHash(scriptHash, net.ScriptHashAddrID)
} }
@ -230,7 +230,7 @@ func (a *AddressScriptHash) ScriptAddress() []byte {
// IsForNet returns whether or not the pay-to-script-hash address is associated // IsForNet returns whether or not the pay-to-script-hash address is associated
// with the passed bitcoin network. // with the passed bitcoin network.
func (a *AddressScriptHash) IsForNet(net *btcnet.Params) bool { func (a *AddressScriptHash) IsForNet(net *chaincfg.Params) bool {
return a.netID == net.ScriptHashAddrID return a.netID == net.ScriptHashAddrID
} }
@ -275,7 +275,7 @@ type AddressPubKey struct {
// NewAddressPubKey returns a new AddressPubKey which represents a pay-to-pubkey // NewAddressPubKey returns a new AddressPubKey which represents a pay-to-pubkey
// address. The serializedPubKey parameter must be a valid pubkey and can be // address. The serializedPubKey parameter must be a valid pubkey and can be
// uncompressed, compressed, or hybrid. // uncompressed, compressed, or hybrid.
func NewAddressPubKey(serializedPubKey []byte, net *btcnet.Params) (*AddressPubKey, error) { func NewAddressPubKey(serializedPubKey []byte, net *chaincfg.Params) (*AddressPubKey, error) {
pubKey, err := btcec.ParsePubKey(serializedPubKey, btcec.S256()) pubKey, err := btcec.ParsePubKey(serializedPubKey, btcec.S256())
if err != nil { if err != nil {
return nil, err return nil, err
@ -338,7 +338,7 @@ func (a *AddressPubKey) ScriptAddress() []byte {
// IsForNet returns whether or not the pay-to-pubkey address is associated // IsForNet returns whether or not the pay-to-pubkey address is associated
// with the passed bitcoin network. // with the passed bitcoin network.
func (a *AddressPubKey) IsForNet(net *btcnet.Params) bool { func (a *AddressPubKey) IsForNet(net *chaincfg.Params) bool {
return a.pubKeyHashID == net.PubKeyHashAddrID return a.pubKeyHashID == net.PubKeyHashAddrID
} }

104
address_test.go
View file

@ -13,8 +13,8 @@ import (
"golang.org/x/crypto/ripemd160" "golang.org/x/crypto/ripemd160"
"github.com/btcsuite/btcd/chaincfg"
"github.com/btcsuite/btcd/wire" "github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil" "github.com/btcsuite/btcutil"
) )
@ -29,7 +29,7 @@ func TestAddresses(t *testing.T) {
valid bool valid bool
result btcutil.Address result btcutil.Address
f func() (btcutil.Address, error) f func() (btcutil.Address, error)
net *btcnet.Params net *chaincfg.Params
}{ }{
// Positive P2PKH tests. // Positive P2PKH tests.
{ {
@ -41,14 +41,14 @@ func TestAddresses(t *testing.T) {
[ripemd160.Size]byte{ [ripemd160.Size]byte{
0xe3, 0x4c, 0xce, 0x70, 0xc8, 0x63, 0x73, 0x27, 0x3e, 0xfc, 0xe3, 0x4c, 0xce, 0x70, 0xc8, 0x63, 0x73, 0x27, 0x3e, 0xfc,
0xc5, 0x4c, 0xe7, 0xd2, 0xa4, 0x91, 0xbb, 0x4a, 0x0e, 0x84}, 0xc5, 0x4c, 0xe7, 0xd2, 0xa4, 0x91, 0xbb, 0x4a, 0x0e, 0x84},
btcnet.MainNetParams.PubKeyHashAddrID), chaincfg.MainNetParams.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
pkHash := []byte{ pkHash := []byte{
0xe3, 0x4c, 0xce, 0x70, 0xc8, 0x63, 0x73, 0x27, 0x3e, 0xfc, 0xe3, 0x4c, 0xce, 0x70, 0xc8, 0x63, 0x73, 0x27, 0x3e, 0xfc,
0xc5, 0x4c, 0xe7, 0xd2, 0xa4, 0x91, 0xbb, 0x4a, 0x0e, 0x84} 0xc5, 0x4c, 0xe7, 0xd2, 0xa4, 0x91, 0xbb, 0x4a, 0x0e, 0x84}
return btcutil.NewAddressPubKeyHash(pkHash, &btcnet.MainNetParams) return btcutil.NewAddressPubKeyHash(pkHash, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
name: "mainnet p2pkh 2", name: "mainnet p2pkh 2",
@ -59,14 +59,14 @@ func TestAddresses(t *testing.T) {
[ripemd160.Size]byte{ [ripemd160.Size]byte{
0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0xf4, 0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0xf4,
0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xaa}, 0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xaa},
btcnet.MainNetParams.PubKeyHashAddrID), chaincfg.MainNetParams.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
pkHash := []byte{ pkHash := []byte{
0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0xf4, 0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0xf4,
0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xaa} 0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xaa}
return btcutil.NewAddressPubKeyHash(pkHash, &btcnet.MainNetParams) return btcutil.NewAddressPubKeyHash(pkHash, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
name: "testnet p2pkh", name: "testnet p2pkh",
@ -77,14 +77,14 @@ func TestAddresses(t *testing.T) {
[ripemd160.Size]byte{ [ripemd160.Size]byte{
0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83, 0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83,
0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f}, 0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f},
btcnet.TestNet3Params.PubKeyHashAddrID), chaincfg.TestNet3Params.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
pkHash := []byte{ pkHash := []byte{
0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83, 0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83,
0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f} 0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f}
return btcutil.NewAddressPubKeyHash(pkHash, &btcnet.TestNet3Params) return btcutil.NewAddressPubKeyHash(pkHash, &chaincfg.TestNet3Params)
}, },
net: &btcnet.TestNet3Params, net: &chaincfg.TestNet3Params,
}, },
// Negative P2PKH tests. // Negative P2PKH tests.
@ -97,7 +97,7 @@ func TestAddresses(t *testing.T) {
0x00, 0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0x00, 0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b,
0xf4, 0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xf4, 0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad,
0xaa} 0xaa}
return btcutil.NewAddressPubKeyHash(pkHash, &btcnet.MainNetParams) return btcutil.NewAddressPubKeyHash(pkHash, &chaincfg.MainNetParams)
}, },
}, },
{ {
@ -119,7 +119,7 @@ func TestAddresses(t *testing.T) {
[ripemd160.Size]byte{ [ripemd160.Size]byte{
0xf8, 0x15, 0xb0, 0x36, 0xd9, 0xbb, 0xbc, 0xe5, 0xe9, 0xf2, 0xf8, 0x15, 0xb0, 0x36, 0xd9, 0xbb, 0xbc, 0xe5, 0xe9, 0xf2,
0xa0, 0x0a, 0xbd, 0x1b, 0xf3, 0xdc, 0x91, 0xe9, 0x55, 0x10}, 0xa0, 0x0a, 0xbd, 0x1b, 0xf3, 0xdc, 0x91, 0xe9, 0x55, 0x10},
btcnet.MainNetParams.ScriptHashAddrID), chaincfg.MainNetParams.ScriptHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
script := []byte{ script := []byte{
0x52, 0x41, 0x04, 0x91, 0xbb, 0xa2, 0x51, 0x09, 0x12, 0xa5, 0x52, 0x41, 0x04, 0x91, 0xbb, 0xa2, 0x51, 0x09, 0x12, 0xa5,
@ -143,9 +143,9 @@ func TestAddresses(t *testing.T) {
0xdb, 0xfb, 0x1e, 0x75, 0x4e, 0x35, 0xfa, 0x1c, 0x78, 0x44, 0xdb, 0xfb, 0x1e, 0x75, 0x4e, 0x35, 0xfa, 0x1c, 0x78, 0x44,
0xc4, 0x1f, 0x32, 0x2a, 0x18, 0x63, 0xd4, 0x62, 0x13, 0x53, 0xc4, 0x1f, 0x32, 0x2a, 0x18, 0x63, 0xd4, 0x62, 0x13, 0x53,
0xae} 0xae}
return btcutil.NewAddressScriptHash(script, &btcnet.MainNetParams) return btcutil.NewAddressScriptHash(script, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
// Taken from transactions: // Taken from transactions:
@ -159,14 +159,14 @@ func TestAddresses(t *testing.T) {
[ripemd160.Size]byte{ [ripemd160.Size]byte{
0xe8, 0xc3, 0x00, 0xc8, 0x79, 0x86, 0xef, 0xa8, 0x4c, 0x37, 0xe8, 0xc3, 0x00, 0xc8, 0x79, 0x86, 0xef, 0xa8, 0x4c, 0x37,
0xc0, 0x51, 0x99, 0x29, 0x01, 0x9e, 0xf8, 0x6e, 0xb5, 0xb4}, 0xc0, 0x51, 0x99, 0x29, 0x01, 0x9e, 0xf8, 0x6e, 0xb5, 0xb4},
btcnet.MainNetParams.ScriptHashAddrID), chaincfg.MainNetParams.ScriptHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
hash := []byte{ hash := []byte{
0xe8, 0xc3, 0x00, 0xc8, 0x79, 0x86, 0xef, 0xa8, 0x4c, 0x37, 0xe8, 0xc3, 0x00, 0xc8, 0x79, 0x86, 0xef, 0xa8, 0x4c, 0x37,
0xc0, 0x51, 0x99, 0x29, 0x01, 0x9e, 0xf8, 0x6e, 0xb5, 0xb4} 0xc0, 0x51, 0x99, 0x29, 0x01, 0x9e, 0xf8, 0x6e, 0xb5, 0xb4}
return btcutil.NewAddressScriptHashFromHash(hash, &btcnet.MainNetParams) return btcutil.NewAddressScriptHashFromHash(hash, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
// Taken from bitcoind base58_keys_valid. // Taken from bitcoind base58_keys_valid.
@ -178,14 +178,14 @@ func TestAddresses(t *testing.T) {
[ripemd160.Size]byte{ [ripemd160.Size]byte{
0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e, 0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e,
0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a}, 0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a},
btcnet.TestNet3Params.ScriptHashAddrID), chaincfg.TestNet3Params.ScriptHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
hash := []byte{ hash := []byte{
0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e, 0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e,
0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a} 0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a}
return btcutil.NewAddressScriptHashFromHash(hash, &btcnet.TestNet3Params) return btcutil.NewAddressScriptHashFromHash(hash, &chaincfg.TestNet3Params)
}, },
net: &btcnet.TestNet3Params, net: &chaincfg.TestNet3Params,
}, },
// Negative P2SH tests. // Negative P2SH tests.
@ -198,7 +198,7 @@ func TestAddresses(t *testing.T) {
0x00, 0xf8, 0x15, 0xb0, 0x36, 0xd9, 0xbb, 0xbc, 0xe5, 0xe9, 0x00, 0xf8, 0x15, 0xb0, 0x36, 0xd9, 0xbb, 0xbc, 0xe5, 0xe9,
0xf2, 0xa0, 0x0a, 0xbd, 0x1b, 0xf3, 0xdc, 0x91, 0xe9, 0x55, 0xf2, 0xa0, 0x0a, 0xbd, 0x1b, 0xf3, 0xdc, 0x91, 0xe9, 0x55,
0x10} 0x10}
return btcutil.NewAddressScriptHashFromHash(hash, &btcnet.MainNetParams) return btcutil.NewAddressScriptHashFromHash(hash, &chaincfg.MainNetParams)
}, },
}, },
@ -214,16 +214,16 @@ func TestAddresses(t *testing.T) {
0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03, 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca, 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
0x52, 0xc6, 0xb4}, 0x52, 0xc6, 0xb4},
btcutil.PKFCompressed, btcnet.MainNetParams.PubKeyHashAddrID), btcutil.PKFCompressed, chaincfg.MainNetParams.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95, 0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03, 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca, 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
0x52, 0xc6, 0xb4} 0x52, 0xc6, 0xb4}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
name: "mainnet p2pk compressed (0x03)", name: "mainnet p2pk compressed (0x03)",
@ -236,16 +236,16 @@ func TestAddresses(t *testing.T) {
0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0, 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e, 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
0xb1, 0x6e, 0x65}, 0xb1, 0x6e, 0x65},
btcutil.PKFCompressed, btcnet.MainNetParams.PubKeyHashAddrID), btcutil.PKFCompressed, chaincfg.MainNetParams.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1, 0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0, 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e, 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
0xb1, 0x6e, 0x65} 0xb1, 0x6e, 0x65}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
name: "mainnet p2pk uncompressed (0x04)", name: "mainnet p2pk uncompressed (0x04)",
@ -262,7 +262,7 @@ func TestAddresses(t *testing.T) {
0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b, 0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43, 0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
0xf6, 0x56, 0xb4, 0x12, 0xa3}, 0xf6, 0x56, 0xb4, 0x12, 0xa3},
btcutil.PKFUncompressed, btcnet.MainNetParams.PubKeyHashAddrID), btcutil.PKFUncompressed, chaincfg.MainNetParams.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b, 0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b,
@ -272,9 +272,9 @@ func TestAddresses(t *testing.T) {
0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b, 0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43, 0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
0xf6, 0x56, 0xb4, 0x12, 0xa3} 0xf6, 0x56, 0xb4, 0x12, 0xa3}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
name: "mainnet p2pk hybrid (0x06)", name: "mainnet p2pk hybrid (0x06)",
@ -291,7 +291,7 @@ func TestAddresses(t *testing.T) {
0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73, 0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c, 0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
0x44, 0xd3, 0x3f, 0x45, 0x3e}, 0x44, 0xd3, 0x3f, 0x45, 0x3e},
btcutil.PKFHybrid, btcnet.MainNetParams.PubKeyHashAddrID), btcutil.PKFHybrid, chaincfg.MainNetParams.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95, 0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
@ -301,9 +301,9 @@ func TestAddresses(t *testing.T) {
0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73, 0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c, 0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
0x44, 0xd3, 0x3f, 0x45, 0x3e} 0x44, 0xd3, 0x3f, 0x45, 0x3e}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
name: "mainnet p2pk hybrid (0x07)", name: "mainnet p2pk hybrid (0x07)",
@ -320,7 +320,7 @@ func TestAddresses(t *testing.T) {
0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71, 0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c, 0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
0x1e, 0x09, 0x08, 0xef, 0x7b}, 0x1e, 0x09, 0x08, 0xef, 0x7b},
btcutil.PKFHybrid, btcnet.MainNetParams.PubKeyHashAddrID), btcutil.PKFHybrid, chaincfg.MainNetParams.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1, 0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
@ -330,9 +330,9 @@ func TestAddresses(t *testing.T) {
0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71, 0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c, 0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
0x1e, 0x09, 0x08, 0xef, 0x7b} 0x1e, 0x09, 0x08, 0xef, 0x7b}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.MainNetParams)
}, },
net: &btcnet.MainNetParams, net: &chaincfg.MainNetParams,
}, },
{ {
name: "testnet p2pk compressed (0x02)", name: "testnet p2pk compressed (0x02)",
@ -345,16 +345,16 @@ func TestAddresses(t *testing.T) {
0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03, 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca, 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
0x52, 0xc6, 0xb4}, 0x52, 0xc6, 0xb4},
btcutil.PKFCompressed, btcnet.TestNet3Params.PubKeyHashAddrID), btcutil.PKFCompressed, chaincfg.TestNet3Params.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95, 0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03, 0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca, 0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
0x52, 0xc6, 0xb4} 0x52, 0xc6, 0xb4}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.TestNet3Params)
}, },
net: &btcnet.TestNet3Params, net: &chaincfg.TestNet3Params,
}, },
{ {
name: "testnet p2pk compressed (0x03)", name: "testnet p2pk compressed (0x03)",
@ -367,16 +367,16 @@ func TestAddresses(t *testing.T) {
0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0, 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e, 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
0xb1, 0x6e, 0x65}, 0xb1, 0x6e, 0x65},
btcutil.PKFCompressed, btcnet.TestNet3Params.PubKeyHashAddrID), btcutil.PKFCompressed, chaincfg.TestNet3Params.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1, 0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0, 0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e, 0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
0xb1, 0x6e, 0x65} 0xb1, 0x6e, 0x65}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.TestNet3Params)
}, },
net: &btcnet.TestNet3Params, net: &chaincfg.TestNet3Params,
}, },
{ {
name: "testnet p2pk uncompressed (0x04)", name: "testnet p2pk uncompressed (0x04)",
@ -393,7 +393,7 @@ func TestAddresses(t *testing.T) {
0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b, 0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43, 0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
0xf6, 0x56, 0xb4, 0x12, 0xa3}, 0xf6, 0x56, 0xb4, 0x12, 0xa3},
btcutil.PKFUncompressed, btcnet.TestNet3Params.PubKeyHashAddrID), btcutil.PKFUncompressed, chaincfg.TestNet3Params.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b, 0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b,
@ -403,9 +403,9 @@ func TestAddresses(t *testing.T) {
0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b, 0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43, 0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
0xf6, 0x56, 0xb4, 0x12, 0xa3} 0xf6, 0x56, 0xb4, 0x12, 0xa3}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.TestNet3Params)
}, },
net: &btcnet.TestNet3Params, net: &chaincfg.TestNet3Params,
}, },
{ {
name: "testnet p2pk hybrid (0x06)", name: "testnet p2pk hybrid (0x06)",
@ -422,7 +422,7 @@ func TestAddresses(t *testing.T) {
0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73, 0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c, 0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
0x44, 0xd3, 0x3f, 0x45, 0x3e}, 0x44, 0xd3, 0x3f, 0x45, 0x3e},
btcutil.PKFHybrid, btcnet.TestNet3Params.PubKeyHashAddrID), btcutil.PKFHybrid, chaincfg.TestNet3Params.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95, 0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
@ -432,9 +432,9 @@ func TestAddresses(t *testing.T) {
0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73, 0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c, 0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
0x44, 0xd3, 0x3f, 0x45, 0x3e} 0x44, 0xd3, 0x3f, 0x45, 0x3e}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.TestNet3Params)
}, },
net: &btcnet.TestNet3Params, net: &chaincfg.TestNet3Params,
}, },
{ {
name: "testnet p2pk hybrid (0x07)", name: "testnet p2pk hybrid (0x07)",
@ -451,7 +451,7 @@ func TestAddresses(t *testing.T) {
0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71, 0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c, 0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
0x1e, 0x09, 0x08, 0xef, 0x7b}, 0x1e, 0x09, 0x08, 0xef, 0x7b},
btcutil.PKFHybrid, btcnet.TestNet3Params.PubKeyHashAddrID), btcutil.PKFHybrid, chaincfg.TestNet3Params.PubKeyHashAddrID),
f: func() (btcutil.Address, error) { f: func() (btcutil.Address, error) {
serializedPubKey := []byte{ serializedPubKey := []byte{
0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1, 0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
@ -461,9 +461,9 @@ func TestAddresses(t *testing.T) {
0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71, 0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c, 0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
0x1e, 0x09, 0x08, 0xef, 0x7b} 0x1e, 0x09, 0x08, 0xef, 0x7b}
return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params) return btcutil.NewAddressPubKey(serializedPubKey, &chaincfg.TestNet3Params)
}, },
net: &btcnet.TestNet3Params, net: &chaincfg.TestNet3Params,
}, },
} }

2
doc.go
View file

@ -35,7 +35,7 @@ To decode/encode an address:
addrString := "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962" + addrString := "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962" +
"e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d57" + "e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d57" +
"8a4c702b6bf11d5f" "8a4c702b6bf11d5f"
defaultNet := &btcnet.MainNetParams defaultNet := &chaincfg.MainNetParams
addr, err := btcutil.DecodeAddress(addrString, defaultNet) addr, err := btcutil.DecodeAddress(addrString, defaultNet)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)

2
hdkeychain/README.md
View file

@ -21,7 +21,7 @@ report. Package hdkeychain is licensed under the liberal ISC license.
- Support for multi-layer derivation - Support for multi-layer derivation
- Easy serialization and deserialization for both private and public extended - Easy serialization and deserialization for both private and public extended
keys keys
- Support for custom networks by registering them with btcnet - Support for custom networks by registering them with chaincfg
- Obtaining the underlying EC pubkeys, EC privkeys, and associated bitcoin - Obtaining the underlying EC pubkeys, EC privkeys, and associated bitcoin
addresses ties in seamlessly with existing btcec and btcutil types which addresses ties in seamlessly with existing btcec and btcutil types which
provide powerful tools for working with them to do things like sign provide powerful tools for working with them to do things like sign

6
hdkeychain/example_test.go
View file

@ -7,7 +7,7 @@ package hdkeychain_test
import ( import (
"fmt" "fmt"
"github.com/btcsuite/btcnet" "github.com/btcsuite/btcd/chaincfg"
"github.com/btcsuite/btcutil/hdkeychain" "github.com/btcsuite/btcutil/hdkeychain"
) )
@ -118,12 +118,12 @@ func Example_defaultWalletLayout() {
// Get and show the address associated with the extended keys for the // Get and show the address associated with the extended keys for the
// main bitcoin network. // main bitcoin network.
acct0ExtAddr, err := acct0Ext10.Address(&btcnet.MainNetParams) acct0ExtAddr, err := acct0Ext10.Address(&chaincfg.MainNetParams)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
acct0IntAddr, err := acct0Int0.Address(&btcnet.MainNetParams) acct0IntAddr, err := acct0Int0.Address(&chaincfg.MainNetParams)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return

12
hdkeychain/extendedkey.go
View file

@ -18,9 +18,9 @@ import (
"fmt" "fmt"
"math/big" "math/big"
"github.com/btcsuite/btcd/chaincfg"
"github.com/btcsuite/btcd/wire" "github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcec" "github.com/btcsuite/btcec"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil" "github.com/btcsuite/btcutil"
"github.com/btcsuite/btcutil/base58" "github.com/btcsuite/btcutil/base58"
) )
@ -321,7 +321,7 @@ func (k *ExtendedKey) Neuter() (*ExtendedKey, error) {
} }
// Get the associated public extended key version bytes. // Get the associated public extended key version bytes.
version, err := btcnet.HDPrivateKeyToPublicKeyID(k.version) version, err := chaincfg.HDPrivateKeyToPublicKeyID(k.version)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -354,7 +354,7 @@ func (k *ExtendedKey) ECPrivKey() (*btcec.PrivateKey, error) {
// Address converts the extended key to a standard bitcoin pay-to-pubkey-hash // Address converts the extended key to a standard bitcoin pay-to-pubkey-hash
// address for the passed network. // address for the passed network.
func (k *ExtendedKey) Address(net *btcnet.Params) (*btcutil.AddressPubKeyHash, error) { func (k *ExtendedKey) Address(net *chaincfg.Params) (*btcutil.AddressPubKeyHash, error) {
pkHash := btcutil.Hash160(k.pubKeyBytes()) pkHash := btcutil.Hash160(k.pubKeyBytes())
return btcutil.NewAddressPubKeyHash(pkHash, net) return btcutil.NewAddressPubKeyHash(pkHash, net)
} }
@ -392,14 +392,14 @@ func (k *ExtendedKey) String() string {
// IsForNet returns whether or not the extended key is associated with the // IsForNet returns whether or not the extended key is associated with the
// passed bitcoin network. // passed bitcoin network.
func (k *ExtendedKey) IsForNet(net *btcnet.Params) bool { func (k *ExtendedKey) IsForNet(net *chaincfg.Params) bool {
return bytes.Equal(k.version, net.HDPrivateKeyID[:]) || return bytes.Equal(k.version, net.HDPrivateKeyID[:]) ||
bytes.Equal(k.version, net.HDPublicKeyID[:]) bytes.Equal(k.version, net.HDPublicKeyID[:])
} }
// SetNet associates the extended key, and any child keys yet to be derived from // SetNet associates the extended key, and any child keys yet to be derived from
// it, with the passed network. // it, with the passed network.
func (k *ExtendedKey) SetNet(net *btcnet.Params) { func (k *ExtendedKey) SetNet(net *chaincfg.Params) {
if k.isPrivate { if k.isPrivate {
k.version = net.HDPrivateKeyID[:] k.version = net.HDPrivateKeyID[:]
} else { } else {
@ -465,7 +465,7 @@ func NewMaster(seed []byte) (*ExtendedKey, error) {
} }
parentFP := []byte{0x00, 0x00, 0x00, 0x00} parentFP := []byte{0x00, 0x00, 0x00, 0x00}
return newExtendedKey(btcnet.MainNetParams.HDPrivateKeyID[:], secretKey, return newExtendedKey(chaincfg.MainNetParams.HDPrivateKeyID[:], secretKey,
chainCode, parentFP, 0, 0, true), nil chainCode, parentFP, 0, 0, true), nil
} }

44
hdkeychain/extendedkey_test.go
View file

@ -15,7 +15,7 @@ import (
"reflect" "reflect"
"testing" "testing"
"github.com/btcsuite/btcnet" "github.com/btcsuite/btcd/chaincfg"
"github.com/btcsuite/btcutil/hdkeychain" "github.com/btcsuite/btcutil/hdkeychain"
) )
@ -432,7 +432,7 @@ func TestExtendedKeyAPI(t *testing.T) {
continue continue
} }
addr, err := key.Address(&btcnet.MainNetParams) addr, err := key.Address(&chaincfg.MainNetParams)
if err != nil { if err != nil {
t.Errorf("Address #%d (%s): unexpected error: %v", i, t.Errorf("Address #%d (%s): unexpected error: %v", i,
test.name, err) test.name, err)
@ -452,8 +452,8 @@ func TestNet(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
key string key string
origNet *btcnet.Params origNet *chaincfg.Params
newNet *btcnet.Params newNet *chaincfg.Params
newPriv string newPriv string
newPub string newPub string
isPrivate bool isPrivate bool
@ -462,8 +462,8 @@ func TestNet(t *testing.T) {
{ {
name: "mainnet -> simnet", name: "mainnet -> simnet",
key: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi", key: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
origNet: &btcnet.MainNetParams, origNet: &chaincfg.MainNetParams,
newNet: &btcnet.SimNetParams, newNet: &chaincfg.SimNetParams,
newPriv: "sprv8Erh3X3hFeKunvVdAGQQtambRPapECWiTDtvsTGdyrhzhbYgnSZajRRWbihzvq4AM4ivm6uso31VfKaukwJJUs3GYihXP8ebhMb3F2AHu3P", newPriv: "sprv8Erh3X3hFeKunvVdAGQQtambRPapECWiTDtvsTGdyrhzhbYgnSZajRRWbihzvq4AM4ivm6uso31VfKaukwJJUs3GYihXP8ebhMb3F2AHu3P",
newPub: "spub4Tr3T2ab61tD1Qa6GHwRFiiKyRRJdfEZpSpXfqgFYCEyaPsqKysqHDjzSzMJSiUEGbcsG3w2SLMoTqn44B8x6u3MLRRkYfACTUBnHK79THk", newPub: "spub4Tr3T2ab61tD1Qa6GHwRFiiKyRRJdfEZpSpXfqgFYCEyaPsqKysqHDjzSzMJSiUEGbcsG3w2SLMoTqn44B8x6u3MLRRkYfACTUBnHK79THk",
isPrivate: true, isPrivate: true,
@ -471,8 +471,8 @@ func TestNet(t *testing.T) {
{ {
name: "simnet -> mainnet", name: "simnet -> mainnet",
key: "sprv8Erh3X3hFeKunvVdAGQQtambRPapECWiTDtvsTGdyrhzhbYgnSZajRRWbihzvq4AM4ivm6uso31VfKaukwJJUs3GYihXP8ebhMb3F2AHu3P", key: "sprv8Erh3X3hFeKunvVdAGQQtambRPapECWiTDtvsTGdyrhzhbYgnSZajRRWbihzvq4AM4ivm6uso31VfKaukwJJUs3GYihXP8ebhMb3F2AHu3P",
origNet: &btcnet.SimNetParams, origNet: &chaincfg.SimNetParams,
newNet: &btcnet.MainNetParams, newNet: &chaincfg.MainNetParams,
newPriv: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi", newPriv: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
newPub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8", newPub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
isPrivate: true, isPrivate: true,
@ -480,8 +480,8 @@ func TestNet(t *testing.T) {
{ {
name: "mainnet -> regtest", name: "mainnet -> regtest",
key: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi", key: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
origNet: &btcnet.MainNetParams, origNet: &chaincfg.MainNetParams,
newNet: &btcnet.RegressionNetParams, newNet: &chaincfg.RegressionNetParams,
newPriv: "tprv8ZgxMBicQKsPeDgjzdC36fs6bMjGApWDNLR9erAXMs5skhMv36j9MV5ecvfavji5khqjWaWSFhN3YcCUUdiKH6isR4Pwy3U5y5egddBr16m", newPriv: "tprv8ZgxMBicQKsPeDgjzdC36fs6bMjGApWDNLR9erAXMs5skhMv36j9MV5ecvfavji5khqjWaWSFhN3YcCUUdiKH6isR4Pwy3U5y5egddBr16m",
newPub: "tpubD6NzVbkrYhZ4XgiXtGrdW5XDAPFCL9h7we1vwNCpn8tGbBcgfVYjXyhWo4E1xkh56hjod1RhGjxbaTLV3X4FyWuejifB9jusQ46QzG87VKp", newPub: "tpubD6NzVbkrYhZ4XgiXtGrdW5XDAPFCL9h7we1vwNCpn8tGbBcgfVYjXyhWo4E1xkh56hjod1RhGjxbaTLV3X4FyWuejifB9jusQ46QzG87VKp",
isPrivate: true, isPrivate: true,
@ -489,8 +489,8 @@ func TestNet(t *testing.T) {
{ {
name: "regtest -> mainnet", name: "regtest -> mainnet",
key: "tprv8ZgxMBicQKsPeDgjzdC36fs6bMjGApWDNLR9erAXMs5skhMv36j9MV5ecvfavji5khqjWaWSFhN3YcCUUdiKH6isR4Pwy3U5y5egddBr16m", key: "tprv8ZgxMBicQKsPeDgjzdC36fs6bMjGApWDNLR9erAXMs5skhMv36j9MV5ecvfavji5khqjWaWSFhN3YcCUUdiKH6isR4Pwy3U5y5egddBr16m",
origNet: &btcnet.RegressionNetParams, origNet: &chaincfg.RegressionNetParams,
newNet: &btcnet.MainNetParams, newNet: &chaincfg.MainNetParams,
newPriv: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi", newPriv: "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
newPub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8", newPub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
isPrivate: true, isPrivate: true,
@ -500,32 +500,32 @@ func TestNet(t *testing.T) {
{ {
name: "mainnet -> simnet", name: "mainnet -> simnet",
key: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8", key: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
origNet: &btcnet.MainNetParams, origNet: &chaincfg.MainNetParams,
newNet: &btcnet.SimNetParams, newNet: &chaincfg.SimNetParams,
newPub: "spub4Tr3T2ab61tD1Qa6GHwRFiiKyRRJdfEZpSpXfqgFYCEyaPsqKysqHDjzSzMJSiUEGbcsG3w2SLMoTqn44B8x6u3MLRRkYfACTUBnHK79THk", newPub: "spub4Tr3T2ab61tD1Qa6GHwRFiiKyRRJdfEZpSpXfqgFYCEyaPsqKysqHDjzSzMJSiUEGbcsG3w2SLMoTqn44B8x6u3MLRRkYfACTUBnHK79THk",
isPrivate: false, isPrivate: false,
}, },
{ {
name: "simnet -> mainnet", name: "simnet -> mainnet",
key: "spub4Tr3T2ab61tD1Qa6GHwRFiiKyRRJdfEZpSpXfqgFYCEyaPsqKysqHDjzSzMJSiUEGbcsG3w2SLMoTqn44B8x6u3MLRRkYfACTUBnHK79THk", key: "spub4Tr3T2ab61tD1Qa6GHwRFiiKyRRJdfEZpSpXfqgFYCEyaPsqKysqHDjzSzMJSiUEGbcsG3w2SLMoTqn44B8x6u3MLRRkYfACTUBnHK79THk",
origNet: &btcnet.SimNetParams, origNet: &chaincfg.SimNetParams,
newNet: &btcnet.MainNetParams, newNet: &chaincfg.MainNetParams,
newPub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8", newPub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
isPrivate: false, isPrivate: false,
}, },
{ {
name: "mainnet -> regtest", name: "mainnet -> regtest",
key: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8", key: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
origNet: &btcnet.MainNetParams, origNet: &chaincfg.MainNetParams,
newNet: &btcnet.RegressionNetParams, newNet: &chaincfg.RegressionNetParams,
newPub: "tpubD6NzVbkrYhZ4XgiXtGrdW5XDAPFCL9h7we1vwNCpn8tGbBcgfVYjXyhWo4E1xkh56hjod1RhGjxbaTLV3X4FyWuejifB9jusQ46QzG87VKp", newPub: "tpubD6NzVbkrYhZ4XgiXtGrdW5XDAPFCL9h7we1vwNCpn8tGbBcgfVYjXyhWo4E1xkh56hjod1RhGjxbaTLV3X4FyWuejifB9jusQ46QzG87VKp",
isPrivate: false, isPrivate: false,
}, },
{ {
name: "regtest -> mainnet", name: "regtest -> mainnet",
key: "tpubD6NzVbkrYhZ4XgiXtGrdW5XDAPFCL9h7we1vwNCpn8tGbBcgfVYjXyhWo4E1xkh56hjod1RhGjxbaTLV3X4FyWuejifB9jusQ46QzG87VKp", key: "tpubD6NzVbkrYhZ4XgiXtGrdW5XDAPFCL9h7we1vwNCpn8tGbBcgfVYjXyhWo4E1xkh56hjod1RhGjxbaTLV3X4FyWuejifB9jusQ46QzG87VKp",
origNet: &btcnet.RegressionNetParams, origNet: &chaincfg.RegressionNetParams,
newNet: &btcnet.MainNetParams, newNet: &chaincfg.MainNetParams,
newPub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8", newPub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
isPrivate: false, isPrivate: false,
}, },
@ -650,7 +650,7 @@ func TestErrors(t *testing.T) {
key: "xbad4LfUL9eKmA66w2GJdVMqhvDmYGJpTGjWRAtjHqoUY17sGaymoMV9Cm3ocn9Ud6Hh2vLFVC7KSKCRVVrqc6dsEdsTjRV1WUmkK85YEUujAPX", key: "xbad4LfUL9eKmA66w2GJdVMqhvDmYGJpTGjWRAtjHqoUY17sGaymoMV9Cm3ocn9Ud6Hh2vLFVC7KSKCRVVrqc6dsEdsTjRV1WUmkK85YEUujAPX",
err: nil, err: nil,
neuter: true, neuter: true,
neuterErr: btcnet.ErrUnknownHDKeyID, neuterErr: chaincfg.ErrUnknownHDKeyID,
}, },
} }
@ -743,7 +743,7 @@ func TestZero(t *testing.T) {
} }
wantAddr := "1HT7xU2Ngenf7D4yocz2SAcnNLW7rK8d4E" wantAddr := "1HT7xU2Ngenf7D4yocz2SAcnNLW7rK8d4E"
addr, err := key.Address(&btcnet.MainNetParams) addr, err := key.Address(&chaincfg.MainNetParams)
if err != nil { if err != nil {
t.Errorf("Addres s #%d (%s): unexpected error: %v", i, t.Errorf("Addres s #%d (%s): unexpected error: %v", i,
testName, err) testName, err)

6
wif.go
View file

@ -8,9 +8,9 @@ import (
"bytes" "bytes"
"errors" "errors"
"github.com/btcsuite/btcd/chaincfg"
"github.com/btcsuite/btcd/wire" "github.com/btcsuite/btcd/wire"
"github.com/btcsuite/btcec" "github.com/btcsuite/btcec"
"github.com/btcsuite/btcnet"
"github.com/btcsuite/btcutil/base58" "github.com/btcsuite/btcutil/base58"
) )
@ -49,7 +49,7 @@ type WIF struct {
// as a string encoded in the Wallet Import Format. The compress argument // as a string encoded in the Wallet Import Format. The compress argument
// specifies whether the address intended to be imported or exported was created // specifies whether the address intended to be imported or exported was created
// by serializing the public key compressed rather than uncompressed. // by serializing the public key compressed rather than uncompressed.
func NewWIF(privKey *btcec.PrivateKey, net *btcnet.Params, compress bool) (*WIF, error) { func NewWIF(privKey *btcec.PrivateKey, net *chaincfg.Params, compress bool) (*WIF, error) {
if net == nil { if net == nil {
return nil, errors.New("no network") return nil, errors.New("no network")
} }
@ -58,7 +58,7 @@ func NewWIF(privKey *btcec.PrivateKey, net *btcnet.Params, compress bool) (*WIF,
// IsForNet returns whether or not the decoded WIF structure is associated // IsForNet returns whether or not the decoded WIF structure is associated
// with the passed bitcoin network. // with the passed bitcoin network.
func (w *WIF) IsForNet(net *btcnet.Params) bool { func (w *WIF) IsForNet(net *chaincfg.Params) bool {
return w.netID == net.PrivateKeyID return w.netID == net.PrivateKeyID
} }

6
wif_test.go
View file

@ -7,8 +7,8 @@ package btcutil_test
import ( import (
"testing" "testing"
"github.com/btcsuite/btcd/chaincfg"
"github.com/btcsuite/btcec" "github.com/btcsuite/btcec"
"github.com/btcsuite/btcnet"
. "github.com/btcsuite/btcutil" . "github.com/btcsuite/btcutil"
) )
@ -25,11 +25,11 @@ func TestEncodeDecodeWIF(t *testing.T) {
0x4e, 0x39, 0x6f, 0xb5, 0xdc, 0x29, 0x5f, 0xe9, 0x4e, 0x39, 0x6f, 0xb5, 0xdc, 0x29, 0x5f, 0xe9,
0x94, 0xb9, 0x67, 0x89, 0xb2, 0x1a, 0x03, 0x98}) 0x94, 0xb9, 0x67, 0x89, 0xb2, 0x1a, 0x03, 0x98})
wif1, err := NewWIF(priv1, &btcnet.MainNetParams, false) wif1, err := NewWIF(priv1, &chaincfg.MainNetParams, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
wif2, err := NewWIF(priv2, &btcnet.TestNet3Params, true) wif2, err := NewWIF(priv2, &chaincfg.TestNet3Params, true)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }