Update Address and WIF APIs to use btcnet.

This change removes all occurances of btcwire.BitcoinNet from exported
APIs, replacing each with *btcnet.Params.  This simplifies the logic
for verifying string encodings of addresses and WIF private keys which
use leading identifier numbers to differentiate between address types
and the network they are intended for.  It also allows the use of this
package for non-standard networks (not mainnet, regtest, or testnet3)
and future proofs it for the possible addition of future testnet
networks.

To update across this change, replace each btcwire.BitcoinNet
parameter with the associated *btcnet.Params.  For the standard
networks, these changes are:

  btcwire.MainNet  -> &btcnet.MainNetParams
  btcwire.TestNet  -> &btcnet.RegressionNetParams
  btcwire.TestNet3 -> &btcnet.TestNet3Params

ok @davecgh

address.go

@@ -10,78 +10,43 @@ import (
 	"encoding/hex"
 	"errors"
 	"github.com/conformal/btcec"
+	"github.com/conformal/btcnet"
 	"github.com/conformal/btcwire"
 )
 
 var (
-	// ErrUnknownNet describes an error where the Bitcoin network is
-	// not recognized.
-	ErrUnknownNet = errors.New("unrecognized bitcoin network")
-
-	// ErrMalformedAddress describes an error where an address is improperly
-	// formatted, either due to an incorrect length of the hashed pubkey or
-	// a non-matching checksum.
-	ErrMalformedAddress = errors.New("malformed address")
-
 	// ErrChecksumMismatch describes an error where decoding failed due
 	// to a bad checksum.
 	ErrChecksumMismatch = errors.New("checksum mismatch")
 
-	// ErrUnknownIdentifier describes an error where decoding failed due
+	// ErrUnknownAddressType describes an error where an address can not
-	// to an unknown magic byte identifier.
+	// decoded as a specific address type due to the string encoding
-	ErrUnknownIdentifier = errors.New("unknown identifier byte")
+	// begining with an identifier byte unknown to any standard or
+	// registered (via btcnet.Register) network.
+	ErrUnknownAddressType = errors.New("unknown address type")
+
+	// ErrAddressCollision describes an error where an address can not
+	// be uniquely determined as either a pay-to-pubkey-hash or
+	// pay-to-script-hash address since the leading identifier is used for
+	// describing both address kinds, but for different networks.  Rather
+	// than assuming or defaulting to one or the other, this error is
+	// returned and the caller must decide how to decode the address.
+	ErrAddressCollision = errors.New("address collision")
 )
 
-// Constants used to specify which network a payment address belongs
-// to.  Mainnet address cannot be used on the Testnet, and vice versa.
-const (
-	// MainNetAddr is the address identifier for MainNet
-	MainNetAddr = 0x00
-
-	// TestNetAddr is the address identifier for TestNet
-	TestNetAddr = 0x6f
-
-	// MainNetScriptHash is the script hash identifier for MainNet
-	MainNetScriptHash = 0x05
-
-	// TestNetScriptHash is the script hash identifier for TestNet
-	TestNetScriptHash = 0xc4
-)
-
-// checkBitcoinNet returns an error if the bitcoin network is not supported.
-func checkBitcoinNet(net btcwire.BitcoinNet) error {
-	// Check for a valid bitcoin network.
-	switch net {
-	case btcwire.MainNet:
-		fallthrough
-	case btcwire.TestNet:
-		fallthrough
-	case btcwire.TestNet3:
-		return nil
-	default:
-		return ErrUnknownNet
-	}
-}
-
 // encodeAddress returns a human-readable payment address given a ripemd160 hash
-// and netid which encodes the bitcoin network and address type.  It is used
+// and netID which encodes the bitcoin network and address type.  It is used
 // in both pay-to-pubkey-hash (P2PKH) and pay-to-script-hash (P2SH) address
 // encoding.
 func encodeAddress(hash160 []byte, netID byte) string {
-	tosum := make([]byte, ripemd160.Size+1)
+	// Format is 1 byte for a network and address class (i.e. P2PKH vs
-	tosum[0] = netID
+	// P2SH), 20 bytes for a RIPEMD160 hash, and 4 bytes of checksum.
-	copy(tosum[1:], hash160)
+	b := make([]byte, 0, 1+ripemd160.Size+4)
-	cksum := btcwire.DoubleSha256(tosum)
+	b = append(b, netID)
-
+	b = append(b, hash160...)
-	// Address before base58 encoding is 1 byte for netID, ripemd160 hash
+	cksum := btcwire.DoubleSha256(b)[:4]
-	// size, plus 4 bytes of checksum (total 25).
+	b = append(b, cksum...)
-	b := make([]byte, ripemd160.Size+5, ripemd160.Size+5)
-	b[0] = netID
-	copy(b[1:], hash160)
-	copy(b[ripemd160.Size+1:], cksum[:4])
-
 	return Base58Encode(b)
-
 }
 
 // Address is an interface type for any type of destination a transaction
@@ -99,7 +64,7 @@ type Address interface {
 
 	// IsForNet returns whether or not the address is associated with the
 	// passed bitcoin network.
-	IsForNet(btcwire.BitcoinNet) bool
+	IsForNet(*btcnet.Params) bool
 }
 
 // DecodeAddress decodes the string encoding of an address and returns
@@ -108,7 +73,7 @@ type Address interface {
 // 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
 // public key, the address will be associated with the passed defaultNet.
-func DecodeAddress(addr string, defaultNet btcwire.BitcoinNet) (Address, error) {
+func DecodeAddress(addr string, defaultNet *btcnet.Params) (Address, error) {
 	// Serialized public keys are either 65 bytes (130 hex chars) if
 	// uncompressed/hybrid or 33 bytes (66 hex chars) if compressed.
 	if len(addr) == 130 || len(addr) == 66 {
@@ -123,28 +88,6 @@ func DecodeAddress(addr string, defaultNet btcwire.BitcoinNet) (Address, error)
 	decoded := Base58Decode(addr)
 	switch len(decoded) {
 	case 1 + ripemd160.Size + 4: // P2PKH or P2SH
-		// Parse the network and hash type (pubkey hash vs script
-		// hash) from the first byte.
-		net := btcwire.MainNet
-		isscript := false
-		switch decoded[0] {
-		case MainNetAddr:
-			// Use defaults.
-
-		case TestNetAddr:
-			net = btcwire.TestNet3
-
-		case MainNetScriptHash:
-			isscript = true
-
-		case TestNetScriptHash:
-			isscript = true
-			net = btcwire.TestNet3
-
-		default:
-			return nil, ErrUnknownIdentifier
-		}
-
 		// Verify hash checksum.  Checksum is calculated as the first
 		// four bytes of double SHA256 of the network byte and hash.
 		tosum := decoded[:ripemd160.Size+1]
@@ -153,13 +96,19 @@ func DecodeAddress(addr string, defaultNet btcwire.BitcoinNet) (Address, error)
 			return nil, ErrChecksumMismatch
 		}
 
-		// Return concrete type.
+		netID := decoded[0]
-		if isscript {
+		isP2PKH := btcnet.IsPubKeyHashAddrID(netID)
-			return NewAddressScriptHashFromHash(
+		isP2SH := btcnet.IsScriptHashAddrID(netID)
-				decoded[1:ripemd160.Size+1], net)
+		switch hash160 := decoded[1 : ripemd160.Size+1]; {
+		case isP2PKH && isP2SH:
+			return nil, ErrAddressCollision
+		case isP2PKH:
+			return newAddressPubKeyHash(hash160, netID)
+		case isP2SH:
+			return newAddressScriptHashFromHash(hash160, netID)
+		default:
+			return nil, ErrUnknownAddressType
 		}
-		return NewAddressPubKeyHash(decoded[1:ripemd160.Size+1],
-			net)
 
 	default:
 		return nil, errors.New("decoded address is of unknown size")
@@ -175,30 +124,21 @@ type AddressPubKeyHash struct {
 
 // NewAddressPubKeyHash returns a new AddressPubKeyHash.  pkHash must
 // be 20 bytes.
-func NewAddressPubKeyHash(pkHash []byte, net btcwire.BitcoinNet) (*AddressPubKeyHash, error) {
+func NewAddressPubKeyHash(pkHash []byte, net *btcnet.Params) (*AddressPubKeyHash, error) {
+	return newAddressPubKeyHash(pkHash, net.PubKeyHashAddrID)
+}
+
+// newAddressPubKeyHash is the internal API to create a pubkey hash address
+// with a known leading identifier byte for a network, rather than looking
+// it up through its parameters.  This is useful when creating a new address
+// structure from a string encoding where the identifer byte is already
+// known.
+func newAddressPubKeyHash(pkHash []byte, netID byte) (*AddressPubKeyHash, error) {
 	// Check for a valid pubkey hash length.
 	if len(pkHash) != ripemd160.Size {
 		return nil, errors.New("pkHash must be 20 bytes")
 	}
 
-	// Check for a valid bitcoin network.
-	if err := checkBitcoinNet(net); err != nil {
-		return nil, err
-	}
-
-	// Choose the appropriate network ID for the address based on the
-	// network.
-	var netID byte
-	switch net {
-	case btcwire.MainNet:
-		netID = MainNetAddr
-
-	case btcwire.TestNet:
-		fallthrough
-	case btcwire.TestNet3:
-		netID = TestNetAddr
-	}
-
 	addr := &AddressPubKeyHash{netID: netID}
 	copy(addr.hash[:], pkHash)
 	return addr, nil
@@ -218,18 +158,8 @@ func (a *AddressPubKeyHash) ScriptAddress() []byte {
 
 // IsForNet returns whether or not the pay-to-pubkey-hash address is associated
 // with the passed bitcoin network.
-func (a *AddressPubKeyHash) IsForNet(net btcwire.BitcoinNet) bool {
+func (a *AddressPubKeyHash) IsForNet(net *btcnet.Params) bool {
-	switch net {
+	return a.netID == net.PubKeyHashAddrID
-	case btcwire.MainNet:
-		return a.netID == MainNetAddr
-
-	case btcwire.TestNet:
-		fallthrough
-	case btcwire.TestNet3:
-		return a.netID == TestNetAddr
-	}
-
-	return false
 }
 
 // String returns a human-readable string for the pay-to-pubkey-hash address.
@@ -253,41 +183,29 @@ type AddressScriptHash struct {
 	netID byte
 }
 
-// NewAddressScriptHash returns a new AddressScriptHash.  net must be
+// NewAddressScriptHash returns a new AddressScriptHash.
-// btcwire.MainNet or btcwire.TestNet3.
+func NewAddressScriptHash(serializedScript []byte, net *btcnet.Params) (*AddressScriptHash, error) {
-func NewAddressScriptHash(serializedScript []byte, net btcwire.BitcoinNet) (*AddressScriptHash, error) {
-	// Create hash of serialized script.
 	scriptHash := Hash160(serializedScript)
-
+	return newAddressScriptHashFromHash(scriptHash, net.ScriptHashAddrID)
-	return NewAddressScriptHashFromHash(scriptHash, net)
 }
 
 // NewAddressScriptHashFromHash returns a new AddressScriptHash.  scriptHash
 // must be 20 bytes.
-func NewAddressScriptHashFromHash(scriptHash []byte, net btcwire.BitcoinNet) (*AddressScriptHash, error) {
+func NewAddressScriptHashFromHash(scriptHash []byte, net *btcnet.Params) (*AddressScriptHash, error) {
+	return newAddressScriptHashFromHash(scriptHash, net.ScriptHashAddrID)
+}
+
+// newAddressScriptHashFromHash is the internal API to create a script hash
+// address with a known leading identifier byte for a network, rather than
+// looking it up through its parameters.  This is useful when creating a new
+// address structure from a string encoding where the identifer byte is already
+// known.
+func newAddressScriptHashFromHash(scriptHash []byte, netID byte) (*AddressScriptHash, error) {
 	// Check for a valid script hash length.
 	if len(scriptHash) != ripemd160.Size {
 		return nil, errors.New("scriptHash must be 20 bytes")
 	}
 
-	// Check for a valid bitcoin network.
-	if err := checkBitcoinNet(net); err != nil {
-		return nil, err
-	}
-
-	// Choose the appropriate network ID for the address based on the
-	// network.
-	var netID byte
-	switch net {
-	case btcwire.MainNet:
-		netID = MainNetScriptHash
-
-	case btcwire.TestNet:
-		fallthrough
-	case btcwire.TestNet3:
-		netID = TestNetScriptHash
-	}
-
 	addr := &AddressScriptHash{netID: netID}
 	copy(addr.hash[:], scriptHash)
 	return addr, nil
@@ -307,17 +225,8 @@ func (a *AddressScriptHash) ScriptAddress() []byte {
 
 // IsForNet returns whether or not the pay-to-script-hash address is associated
 // with the passed bitcoin network.
-func (a *AddressScriptHash) IsForNet(net btcwire.BitcoinNet) bool {
+func (a *AddressScriptHash) IsForNet(net *btcnet.Params) bool {
-	switch net {
+	return a.netID == net.ScriptHashAddrID
-	case btcwire.MainNet:
-		return a.netID == MainNetScriptHash
-	case btcwire.TestNet:
-		fallthrough
-	case btcwire.TestNet3:
-		return a.netID == TestNetScriptHash
-	}
-
-	return false
 }
 
 // String returns a human-readable string for the pay-to-script-hash address.
@@ -355,13 +264,13 @@ const (
 type AddressPubKey struct {
 	pubKeyFormat PubKeyFormat
 	pubKey       *btcec.PublicKey
-	netID        byte
+	pubKeyHashID byte
 }
 
 // NewAddressPubKey returns a new AddressPubKey which represents a pay-to-pubkey
 // address.  The serializedPubKey parameter must be a valid pubkey and can be
 // uncompressed, compressed, or hybrid.
-func NewAddressPubKey(serializedPubKey []byte, net btcwire.BitcoinNet) (*AddressPubKey, error) {
+func NewAddressPubKey(serializedPubKey []byte, net *btcnet.Params) (*AddressPubKey, error) {
 	pubKey, err := btcec.ParsePubKey(serializedPubKey, btcec.S256())
 	if err != nil {
 		return nil, err
@@ -373,61 +282,34 @@ func NewAddressPubKey(serializedPubKey []byte, net btcwire.BitcoinNet) (*Address
 	// the leading byte to get the format.
 	pkFormat := PKFUncompressed
 	switch serializedPubKey[0] {
-	case 0x02:
+	case 0x02, 0x03:
-		fallthrough
-	case 0x03:
 		pkFormat = PKFCompressed
-
+	case 0x06, 0x07:
-	case 0x06:
-		fallthrough
-	case 0x07:
 		pkFormat = PKFHybrid
 	}
 
-	// Check for a valid bitcoin network.
-	if err := checkBitcoinNet(net); err != nil {
-		return nil, err
-	}
-
-	// Choose the appropriate network ID for the address based on the
-	// network.
-	var netID byte
-	switch net {
-	case btcwire.MainNet:
-		netID = MainNetAddr
-
-	case btcwire.TestNet:
-		fallthrough
-	case btcwire.TestNet3:
-		netID = TestNetAddr
-	}
-
-	ecPubKey := pubKey
 	return &AddressPubKey{
 		pubKeyFormat: pkFormat,
-		pubKey:       ecPubKey,
+		pubKey:       pubKey,
-		netID:        netID,
+		pubKeyHashID: net.PubKeyHashAddrID,
 	}, nil
 }
 
 // serialize returns the serialization of the public key according to the
 // format associated with the address.
 func (a *AddressPubKey) serialize() []byte {
-	var serializedPubKey []byte
 	switch a.pubKeyFormat {
 	default:
 		fallthrough
 	case PKFUncompressed:
-		serializedPubKey = a.pubKey.SerializeUncompressed()
+		return a.pubKey.SerializeUncompressed()
 
 	case PKFCompressed:
-		serializedPubKey = a.pubKey.SerializeCompressed()
+		return a.pubKey.SerializeCompressed()
 
 	case PKFHybrid:
-		serializedPubKey = a.pubKey.SerializeHybrid()
+		return a.pubKey.SerializeHybrid()
 	}
-
-	return serializedPubKey
 }
 
 // EncodeAddress returns the string encoding of the public key as a
@@ -439,7 +321,7 @@ func (a *AddressPubKey) serialize() []byte {
 //
 // Part of the Address interface.
 func (a *AddressPubKey) EncodeAddress() string {
-	return encodeAddress(Hash160(a.serialize()), a.netID)
+	return encodeAddress(Hash160(a.serialize()), a.pubKeyHashID)
 }
 
 // ScriptAddress returns the bytes to be included in a txout script to pay
@@ -451,18 +333,8 @@ func (a *AddressPubKey) ScriptAddress() []byte {
 
 // IsForNet returns whether or not the pay-to-pubkey address is associated
 // with the passed bitcoin network.
-func (a *AddressPubKey) IsForNet(net btcwire.BitcoinNet) bool {
+func (a *AddressPubKey) IsForNet(net *btcnet.Params) bool {
-	switch net {
+	return a.pubKeyHashID == net.PubKeyHashAddrID
-	case btcwire.MainNet:
-		return a.netID == MainNetAddr
-
-	case btcwire.TestNet:
-		fallthrough
-	case btcwire.TestNet3:
-		return a.netID == TestNetAddr
-	}
-
-	return false
 }
 
 // String returns the hex-encoded human-readable string for the pay-to-pubkey
@@ -490,10 +362,9 @@ func (a *AddressPubKey) SetFormat(pkFormat PubKeyFormat) {
 // differs with the format.  At the time of this writing, most Bitcoin addresses
 // are pay-to-pubkey-hash constructed from the uncompressed public key.
 func (a *AddressPubKey) AddressPubKeyHash() *AddressPubKeyHash {
-	addr := &AddressPubKeyHash{netID: a.netID}
+	addr := &AddressPubKeyHash{netID: a.pubKeyHashID}
 	copy(addr.hash[:], Hash160(a.serialize()))
 	return addr
-
 }
 
 // PubKey returns the underlying public key for the address.

address_test.go

@@ -6,13 +6,16 @@ package btcutil_test
 
 import (
 	"bytes"
-	"code.google.com/p/go.crypto/ripemd160"
 	"encoding/hex"
 	"fmt"
-	"github.com/conformal/btcutil"
-	"github.com/conformal/btcwire"
 	"reflect"
 	"testing"
+
+	"code.google.com/p/go.crypto/ripemd160"
+
+	"github.com/conformal/btcnet"
+	"github.com/conformal/btcutil"
+	"github.com/conformal/btcwire"
 )
 
 // invalidNet is an invalid bitcoin network.
@@ -26,7 +29,7 @@ func TestAddresses(t *testing.T) {
 		valid   bool
 		result  btcutil.Address
 		f       func() (btcutil.Address, error)
-		net     btcwire.BitcoinNet
+		net     *btcnet.Params
 	}{
 		// Positive P2PKH tests.
 		{
@@ -38,14 +41,14 @@ func TestAddresses(t *testing.T) {
 				[ripemd160.Size]byte{
 					0xe3, 0x4c, 0xce, 0x70, 0xc8, 0x63, 0x73, 0x27, 0x3e, 0xfc,
 					0xc5, 0x4c, 0xe7, 0xd2, 0xa4, 0x91, 0xbb, 0x4a, 0x0e, 0x84},
-				btcutil.MainNetAddr),
+				btcnet.MainNetParams.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				pkHash := []byte{
 					0xe3, 0x4c, 0xce, 0x70, 0xc8, 0x63, 0x73, 0x27, 0x3e, 0xfc,
 					0xc5, 0x4c, 0xe7, 0xd2, 0xa4, 0x91, 0xbb, 0x4a, 0x0e, 0x84}
-				return btcutil.NewAddressPubKeyHash(pkHash, btcwire.MainNet)
+				return btcutil.NewAddressPubKeyHash(pkHash, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			name:    "mainnet p2pkh 2",
@@ -56,14 +59,14 @@ func TestAddresses(t *testing.T) {
 				[ripemd160.Size]byte{
 					0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0xf4,
 					0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xaa},
-				btcutil.MainNetAddr),
+				btcnet.MainNetParams.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				pkHash := []byte{
 					0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b, 0xf4,
 					0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad, 0xaa}
-				return btcutil.NewAddressPubKeyHash(pkHash, btcwire.MainNet)
+				return btcutil.NewAddressPubKeyHash(pkHash, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			name:    "testnet p2pkh",
@@ -74,29 +77,17 @@ func TestAddresses(t *testing.T) {
 				[ripemd160.Size]byte{
 					0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83,
 					0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f},
-				btcutil.TestNetAddr),
+				btcnet.TestNet3Params.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				pkHash := []byte{
 					0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83,
 					0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f}
-				return btcutil.NewAddressPubKeyHash(pkHash, btcwire.TestNet3)
+				return btcutil.NewAddressPubKeyHash(pkHash, &btcnet.TestNet3Params)
 			},
-			net: btcwire.TestNet3,
+			net: &btcnet.TestNet3Params,
 		},
 
 		// Negative P2PKH tests.
-		{
-			name:    "p2pkh wrong byte identifier/net",
-			addr:    "MrX9vMRYLfVy1BnZbc5gZjuyaqH3ZW2ZHz",
-			encoded: "MrX9vMRYLfVy1BnZbc5gZjuyaqH3ZW2ZHz",
-			valid:   false,
-			f: func() (btcutil.Address, error) {
-				pkHash := []byte{
-					0x78, 0xb3, 0x16, 0xa0, 0x86, 0x47, 0xd5, 0xb7, 0x72, 0x83,
-					0xe5, 0x12, 0xd3, 0x60, 0x3f, 0x1f, 0x1c, 0x8d, 0xe6, 0x8f}
-				return btcutil.NewAddressPubKeyHash(pkHash, invalidNet)
-			},
-		},
 		{
 			name:  "p2pkh wrong hash length",
 			addr:  "",
@@ -106,7 +97,7 @@ func TestAddresses(t *testing.T) {
 					0x00, 0x0e, 0xf0, 0x30, 0x10, 0x7f, 0xd2, 0x6e, 0x0b, 0x6b,
 					0xf4, 0x05, 0x12, 0xbc, 0xa2, 0xce, 0xb1, 0xdd, 0x80, 0xad,
 					0xaa}
-				return btcutil.NewAddressPubKeyHash(pkHash, btcwire.MainNet)
+				return btcutil.NewAddressPubKeyHash(pkHash, &btcnet.MainNetParams)
 			},
 		},
 		{
@@ -128,7 +119,7 @@ func TestAddresses(t *testing.T) {
 				[ripemd160.Size]byte{
 					0xf8, 0x15, 0xb0, 0x36, 0xd9, 0xbb, 0xbc, 0xe5, 0xe9, 0xf2,
 					0xa0, 0x0a, 0xbd, 0x1b, 0xf3, 0xdc, 0x91, 0xe9, 0x55, 0x10},
-				btcutil.MainNetScriptHash),
+				btcnet.MainNetParams.ScriptHashAddrID),
 			f: func() (btcutil.Address, error) {
 				script := []byte{
 					0x52, 0x41, 0x04, 0x91, 0xbb, 0xa2, 0x51, 0x09, 0x12, 0xa5,
@@ -152,9 +143,9 @@ func TestAddresses(t *testing.T) {
 					0xdb, 0xfb, 0x1e, 0x75, 0x4e, 0x35, 0xfa, 0x1c, 0x78, 0x44,
 					0xc4, 0x1f, 0x32, 0x2a, 0x18, 0x63, 0xd4, 0x62, 0x13, 0x53,
 					0xae}
-				return btcutil.NewAddressScriptHash(script, btcwire.MainNet)
+				return btcutil.NewAddressScriptHash(script, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			// Taken from transactions:
@@ -168,14 +159,14 @@ func TestAddresses(t *testing.T) {
 				[ripemd160.Size]byte{
 					0xe8, 0xc3, 0x00, 0xc8, 0x79, 0x86, 0xef, 0xa8, 0x4c, 0x37,
 					0xc0, 0x51, 0x99, 0x29, 0x01, 0x9e, 0xf8, 0x6e, 0xb5, 0xb4},
-				btcutil.MainNetScriptHash),
+				btcnet.MainNetParams.ScriptHashAddrID),
 			f: func() (btcutil.Address, error) {
 				hash := []byte{
 					0xe8, 0xc3, 0x00, 0xc8, 0x79, 0x86, 0xef, 0xa8, 0x4c, 0x37,
 					0xc0, 0x51, 0x99, 0x29, 0x01, 0x9e, 0xf8, 0x6e, 0xb5, 0xb4}
-				return btcutil.NewAddressScriptHashFromHash(hash, btcwire.MainNet)
+				return btcutil.NewAddressScriptHashFromHash(hash, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			// Taken from bitcoind base58_keys_valid.
@@ -187,14 +178,14 @@ func TestAddresses(t *testing.T) {
 				[ripemd160.Size]byte{
 					0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e,
 					0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a},
-				btcutil.TestNetScriptHash),
+				btcnet.TestNet3Params.ScriptHashAddrID),
 			f: func() (btcutil.Address, error) {
 				hash := []byte{
 					0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e,
 					0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a}
-				return btcutil.NewAddressScriptHashFromHash(hash, btcwire.TestNet3)
+				return btcutil.NewAddressScriptHashFromHash(hash, &btcnet.TestNet3Params)
 			},
-			net: btcwire.TestNet3,
+			net: &btcnet.TestNet3Params,
 		},
 
 		// Negative P2SH tests.
@@ -207,18 +198,7 @@ func TestAddresses(t *testing.T) {
 					0x00, 0xf8, 0x15, 0xb0, 0x36, 0xd9, 0xbb, 0xbc, 0xe5, 0xe9,
 					0xf2, 0xa0, 0x0a, 0xbd, 0x1b, 0xf3, 0xdc, 0x91, 0xe9, 0x55,
 					0x10}
-				return btcutil.NewAddressScriptHashFromHash(hash, btcwire.MainNet)
+				return btcutil.NewAddressScriptHashFromHash(hash, &btcnet.MainNetParams)
-			},
-		},
-		{
-			name:  "p2sh wrong byte identifier/net",
-			addr:  "0NBFNJTktNa7GZusGbDbGKRZTxdK9VVez3n",
-			valid: false,
-			f: func() (btcutil.Address, error) {
-				hash := []byte{
-					0xc5, 0x79, 0x34, 0x2c, 0x2c, 0x4c, 0x92, 0x20, 0x20, 0x5e,
-					0x2c, 0xdc, 0x28, 0x56, 0x17, 0x04, 0x0c, 0x92, 0x4a, 0x0a}
-				return btcutil.NewAddressScriptHashFromHash(hash, invalidNet)
 			},
 		},
 
@@ -234,16 +214,16 @@ func TestAddresses(t *testing.T) {
 					0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
 					0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
 					0x52, 0xc6, 0xb4},
-				btcutil.PKFCompressed, btcutil.MainNetAddr),
+				btcutil.PKFCompressed, btcnet.MainNetParams.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
 					0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
 					0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
 					0x52, 0xc6, 0xb4}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.MainNet)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			name:    "mainnet p2pk compressed (0x03)",
@@ -256,16 +236,16 @@ func TestAddresses(t *testing.T) {
 					0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
 					0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
 					0xb1, 0x6e, 0x65},
-				btcutil.PKFCompressed, btcutil.MainNetAddr),
+				btcutil.PKFCompressed, btcnet.MainNetParams.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
 					0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
 					0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
 					0xb1, 0x6e, 0x65}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.MainNet)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			name: "mainnet p2pk uncompressed (0x04)",
@@ -282,7 +262,7 @@ func TestAddresses(t *testing.T) {
 					0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
 					0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
 					0xf6, 0x56, 0xb4, 0x12, 0xa3},
-				btcutil.PKFUncompressed, btcutil.MainNetAddr),
+				btcutil.PKFUncompressed, btcnet.MainNetParams.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b,
@@ -292,9 +272,9 @@ func TestAddresses(t *testing.T) {
 					0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
 					0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
 					0xf6, 0x56, 0xb4, 0x12, 0xa3}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.MainNet)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			name: "mainnet p2pk hybrid (0x06)",
@@ -311,7 +291,7 @@ func TestAddresses(t *testing.T) {
 					0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
 					0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
 					0x44, 0xd3, 0x3f, 0x45, 0x3e},
-				btcutil.PKFHybrid, btcutil.MainNetAddr),
+				btcutil.PKFHybrid, btcnet.MainNetParams.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
@@ -321,9 +301,9 @@ func TestAddresses(t *testing.T) {
 					0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
 					0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
 					0x44, 0xd3, 0x3f, 0x45, 0x3e}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.MainNet)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			name: "mainnet p2pk hybrid (0x07)",
@@ -340,7 +320,7 @@ func TestAddresses(t *testing.T) {
 					0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
 					0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
 					0x1e, 0x09, 0x08, 0xef, 0x7b},
-				btcutil.PKFHybrid, btcutil.MainNetAddr),
+				btcutil.PKFHybrid, btcnet.MainNetParams.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
@@ -350,9 +330,9 @@ func TestAddresses(t *testing.T) {
 					0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
 					0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
 					0x1e, 0x09, 0x08, 0xef, 0x7b}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.MainNet)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.MainNetParams)
 			},
-			net: btcwire.MainNet,
+			net: &btcnet.MainNetParams,
 		},
 		{
 			name:    "testnet p2pk compressed (0x02)",
@@ -365,16 +345,16 @@ func TestAddresses(t *testing.T) {
 					0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
 					0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
 					0x52, 0xc6, 0xb4},
-				btcutil.PKFCompressed, btcutil.TestNetAddr),
+				btcutil.PKFCompressed, btcnet.TestNet3Params.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x02, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
 					0x69, 0xc2, 0xe7, 0x79, 0x01, 0x57, 0x3d, 0x8d, 0x79, 0x03,
 					0xc3, 0xeb, 0xec, 0x3a, 0x95, 0x77, 0x24, 0x89, 0x5d, 0xca,
 					0x52, 0xc6, 0xb4}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.TestNet3)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params)
 			},
-			net: btcwire.TestNet3,
+			net: &btcnet.TestNet3Params,
 		},
 		{
 			name:    "testnet p2pk compressed (0x03)",
@@ -387,16 +367,16 @@ func TestAddresses(t *testing.T) {
 					0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
 					0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
 					0xb1, 0x6e, 0x65},
-				btcutil.PKFCompressed, btcutil.TestNetAddr),
+				btcutil.PKFCompressed, btcnet.TestNet3Params.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x03, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
 					0xe9, 0x86, 0xe8, 0x84, 0x18, 0x5c, 0x61, 0xcf, 0x43, 0xe0,
 					0x01, 0xf9, 0x13, 0x7f, 0x23, 0xc2, 0xc4, 0x09, 0x27, 0x3e,
 					0xb1, 0x6e, 0x65}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.TestNet3)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params)
 			},
-			net: btcwire.TestNet3,
+			net: &btcnet.TestNet3Params,
 		},
 		{
 			name: "testnet p2pk uncompressed (0x04)",
@@ -413,7 +393,7 @@ func TestAddresses(t *testing.T) {
 					0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
 					0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
 					0xf6, 0x56, 0xb4, 0x12, 0xa3},
-				btcutil.PKFUncompressed, btcutil.TestNetAddr),
+				btcutil.PKFUncompressed, btcnet.TestNet3Params.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x04, 0x11, 0xdb, 0x93, 0xe1, 0xdc, 0xdb, 0x8a, 0x01, 0x6b,
@@ -423,9 +403,9 @@ func TestAddresses(t *testing.T) {
 					0xf9, 0x74, 0x44, 0x64, 0xf8, 0x2e, 0x16, 0x0b, 0xfa, 0x9b,
 					0x8b, 0x64, 0xf9, 0xd4, 0xc0, 0x3f, 0x99, 0x9b, 0x86, 0x43,
 					0xf6, 0x56, 0xb4, 0x12, 0xa3}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.TestNet3)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params)
 			},
-			net: btcwire.TestNet3,
+			net: &btcnet.TestNet3Params,
 		},
 		{
 			name: "testnet p2pk hybrid (0x06)",
@@ -442,7 +422,7 @@ func TestAddresses(t *testing.T) {
 					0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
 					0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
 					0x44, 0xd3, 0x3f, 0x45, 0x3e},
-				btcutil.PKFHybrid, btcutil.TestNetAddr),
+				btcutil.PKFHybrid, btcnet.TestNet3Params.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x06, 0x19, 0x2d, 0x74, 0xd0, 0xcb, 0x94, 0x34, 0x4c, 0x95,
@@ -452,9 +432,9 @@ func TestAddresses(t *testing.T) {
 					0x96, 0x85, 0x26, 0x62, 0xce, 0x6a, 0x84, 0x7b, 0x19, 0x73,
 					0x76, 0x83, 0x01, 0x60, 0xc6, 0xd2, 0xeb, 0x5e, 0x6a, 0x4c,
 					0x44, 0xd3, 0x3f, 0x45, 0x3e}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.TestNet3)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params)
 			},
-			net: btcwire.TestNet3,
+			net: &btcnet.TestNet3Params,
 		},
 		{
 			name: "testnet p2pk hybrid (0x07)",
@@ -471,7 +451,7 @@ func TestAddresses(t *testing.T) {
 					0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
 					0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
 					0x1e, 0x09, 0x08, 0xef, 0x7b},
-				btcutil.PKFHybrid, btcutil.TestNetAddr),
+				btcutil.PKFHybrid, btcnet.TestNet3Params.PubKeyHashAddrID),
 			f: func() (btcutil.Address, error) {
 				serializedPubKey := []byte{
 					0x07, 0xb0, 0xbd, 0x63, 0x42, 0x34, 0xab, 0xbb, 0x1b, 0xa1,
@@ -481,9 +461,9 @@ func TestAddresses(t *testing.T) {
 					0x8a, 0x7e, 0xf8, 0xbd, 0x3b, 0x3c, 0xfb, 0x1e, 0xdb, 0x71,
 					0x17, 0xab, 0x65, 0x12, 0x9b, 0x8a, 0x2e, 0x68, 0x1f, 0x3c,
 					0x1e, 0x09, 0x08, 0xef, 0x7b}
-				return btcutil.NewAddressPubKey(serializedPubKey, btcwire.TestNet3)
+				return btcutil.NewAddressPubKey(serializedPubKey, &btcnet.TestNet3Params)
 			},
-			net: btcwire.TestNet3,
+			net: &btcnet.TestNet3Params,
 		},
 	}
 

internal_test.go

@@ -60,7 +60,7 @@ func TstAddressPubKey(serializedPubKey []byte, pubKeyFormat PubKeyFormat,
 	return &AddressPubKey{
 		pubKeyFormat: pubKeyFormat,
 		pubKey:       (*btcec.PublicKey)(pubKey),
-		netID:        netID,
+		pubKeyHashID: netID,
 	}
 }
 

test_coverage.txt

@@ -2,65 +2,66 @@
 github.com/conformal/btcutil/base58.go	 Base58Decode			 100.00% (20/20)
 github.com/conformal/btcutil/base58.go	 Base58Encode			 100.00% (15/15)
 github.com/conformal/btcutil/block.go	 Block.Tx			 100.00% (12/12)
-github.com/conformal/btcutil/wif.go	 WIF.String			 100.00% (11/11)
 github.com/conformal/btcutil/block.go	 Block.Transactions		 100.00% (11/11)
-github.com/conformal/btcutil/address.go	 encodeAddress			 100.00% (9/9)
+github.com/conformal/btcutil/wif.go	 WIF.String			 100.00% (11/11)
 github.com/conformal/btcutil/amount.go	 NewAmount			 100.00% (9/9)
 github.com/conformal/btcutil/amount.go	 AmountUnit.String		 100.00% (8/8)
 github.com/conformal/btcutil/block.go	 NewBlockFromBytes		 100.00% (7/7)
 github.com/conformal/btcutil/tx.go	 NewTxFromBytes			 100.00% (7/7)
-github.com/conformal/btcutil/block.go	 Block.Sha			 100.00% (5/5)
+github.com/conformal/btcutil/address.go	 encodeAddress			 100.00% (6/6)
+github.com/conformal/btcutil/address.go	 newAddressScriptHashFromHash	 100.00% (5/5)
 github.com/conformal/btcutil/tx.go	 Tx.Sha				 100.00% (5/5)
-github.com/conformal/btcutil/address.go	 checkBitcoinNet		 100.00% (5/5)
+github.com/conformal/btcutil/block.go	 Block.Sha			 100.00% (5/5)
+github.com/conformal/btcutil/address.go	 newAddressPubKeyHash		 100.00% (5/5)
 github.com/conformal/btcutil/hash160.go	 calcHash			 100.00% (2/2)
-github.com/conformal/btcutil/amount.go	 Amount.Format			 100.00% (2/2)
 github.com/conformal/btcutil/address.go	 NewAddressScriptHash		 100.00% (2/2)
-github.com/conformal/btcutil/block.go	 NewBlockFromBlockAndBytes	 100.00% (1/1)
+github.com/conformal/btcutil/amount.go	 Amount.Format			 100.00% (2/2)
-github.com/conformal/btcutil/amount.go	 Amount.ToUnit			 100.00% (1/1)
 github.com/conformal/btcutil/amount.go	 Amount.String			 100.00% (1/1)
-github.com/conformal/btcutil/address.go	 AddressPubKeyHash.String	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKeyHash.Hash160	 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 OutOfRangeError.Error		 100.00% (1/1)
 github.com/conformal/btcutil/block.go	 Block.MsgBlock			 100.00% (1/1)
-github.com/conformal/btcutil/block.go	 NewBlock			 100.00% (1/1)
+github.com/conformal/btcutil/tx.go	 Tx.SetIndex			 100.00% (1/1)
-github.com/conformal/btcutil/block.go	 Block.SetHeight		 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 NewAddressPubKeyHash		 100.00% (1/1)
-github.com/conformal/btcutil/block.go	 Block.Height			 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressPubKeyHash.EncodeAddress 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressPubKeyHash.ScriptAddress 100.00% (1/1)
-github.com/conformal/btcutil/address.go	 AddressPubKeyHash.Hash160	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKeyHash.IsForNet	 100.00% (1/1)
-github.com/conformal/btcutil/tx.go	 NewTx				 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKeyHash.String	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 NewAddressScriptHashFromHash	 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressScriptHash.EncodeAddress 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressScriptHash.ScriptAddress 100.00% (1/1)
-github.com/conformal/btcutil/tx.go	 Tx.SetIndex			 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressScriptHash.IsForNet	 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressScriptHash.String	 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressScriptHash.Hash160	 100.00% (1/1)
-github.com/conformal/btcutil/tx.go	 Tx.Index			 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressPubKey.EncodeAddress	 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressPubKey.ScriptAddress	 100.00% (1/1)
-github.com/conformal/btcutil/tx.go	 Tx.MsgTx			 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKey.IsForNet		 100.00% (1/1)
 github.com/conformal/btcutil/address.go	 AddressPubKey.String		 100.00% (1/1)
+github.com/conformal/btcutil/amount.go	 Amount.ToUnit			 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 Block.Height			 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 Block.SetHeight		 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 NewBlock			 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 NewBlockFromBlockAndBytes	 100.00% (1/1)
 github.com/conformal/btcutil/hash160.go	 Hash160			 100.00% (1/1)
-github.com/conformal/btcutil/block.go	 OutOfRangeError.Error		 100.00% (1/1)
+github.com/conformal/btcutil/tx.go	 Tx.MsgTx			 100.00% (1/1)
-github.com/conformal/btcutil/address.go	 DecodeAddress			 95.65% (22/23)
+github.com/conformal/btcutil/tx.go	 Tx.Index			 100.00% (1/1)
+github.com/conformal/btcutil/tx.go	 NewTx				 100.00% (1/1)
 github.com/conformal/btcutil/appdata.go	 appDataDir			 92.00% (23/25)
-github.com/conformal/btcutil/address.go	 NewAddressPubKeyHash		 91.67% (11/12)
-github.com/conformal/btcutil/address.go	 NewAddressScriptHashFromHash	 91.67% (11/12)
 github.com/conformal/btcutil/block.go	 Block.TxLoc			 88.89% (8/9)
 github.com/conformal/btcutil/block.go	 Block.Bytes			 88.89% (8/9)
-github.com/conformal/btcutil/address.go	 AddressPubKey.serialize	 85.71% (6/7)
+github.com/conformal/btcutil/address.go	 NewAddressPubKey		 87.50% (7/8)
-github.com/conformal/btcutil/address.go	 NewAddressPubKey		 83.33% (15/18)
+github.com/conformal/btcutil/address.go	 DecodeAddress			 85.00% (17/20)
-github.com/conformal/btcutil/wif.go	 DecodeWIF			 81.82% (18/22)
+github.com/conformal/btcutil/wif.go	 DecodeWIF			 85.00% (17/20)
-github.com/conformal/btcutil/wif.go	 NewWIF				 75.00% (3/4)
+github.com/conformal/btcutil/address.go	 AddressPubKey.serialize	 80.00% (4/5)
 github.com/conformal/btcutil/block.go	 Block.TxSha			 75.00% (3/4)
 github.com/conformal/btcutil/wif.go	 paddedAppend			 66.67% (2/3)
-github.com/conformal/btcutil/address.go	 AddressPubKey.IsForNet		 60.00% (3/5)
+github.com/conformal/btcutil/wif.go	 NewWIF				 66.67% (2/3)
-github.com/conformal/btcutil/address.go	 AddressScriptHash.IsForNet	 60.00% (3/5)
-github.com/conformal/btcutil/address.go	 AddressPubKeyHash.IsForNet	 60.00% (3/5)
 github.com/conformal/btcutil/certgen.go	 NewTLSCertPair			 0.00% (0/50)
 github.com/conformal/btcutil/wif.go	 WIF.SerializePubKey		 0.00% (0/4)
-github.com/conformal/btcutil/wif.go	 WIF.IsForNet			 0.00% (0/4)
 github.com/conformal/btcutil/address.go	 AddressPubKey.AddressPubKeyHash 0.00% (0/3)
-github.com/conformal/btcutil/appdata.go	 AppDataDir			 0.00% (0/1)
-github.com/conformal/btcutil/address.go	 AddressPubKey.Format		 0.00% (0/1)
 github.com/conformal/btcutil/address.go	 AddressPubKey.SetFormat	 0.00% (0/1)
+github.com/conformal/btcutil/appdata.go	 AppDataDir			 0.00% (0/1)
 github.com/conformal/btcutil/address.go	 AddressPubKey.PubKey		 0.00% (0/1)
-github.com/conformal/btcutil		 ------------------------------- 76.70% (293/382)
+github.com/conformal/btcutil/wif.go	 WIF.IsForNet			 0.00% (0/1)
+github.com/conformal/btcutil/address.go	 AddressPubKey.Format		 0.00% (0/1)
+github.com/conformal/btcutil		 ------------------------------- 76.60% (252/329)
 

wif.go

@@ -9,6 +9,7 @@ import (
 	"errors"
 
 	"github.com/conformal/btcec"
+	"github.com/conformal/btcnet"
 	"github.com/conformal/btcwire"
 )
 
@@ -18,21 +19,9 @@ import (
 // encountered.
 var ErrMalformedPrivateKey = errors.New("malformed private key")
 
-// These constants define the magic numbers used for identifing components
+// compressMagic is the magic byte used to identify a WIF encoding for
-// of a WIF-encoded private key and the bitcoin address associated with it.
+// an address created from a compressed serialized public key.
-const (
+const compressMagic byte = 0x01
-	// mainNetKey is the magic number identifying a WIF private key for
-	// the MainNet bitcoin network.
-	mainNetKey byte = 0x80
-
-	// testNetKey is the magic number identifying a WIF private key for
-	// the regression test and TestNet3 bitcoin networks.
-	testNetKey byte = 0xef
-
-	// compressMagic is the magic byte used to identify a WIF encoding for
-	// an address created from a compressed serialized public key.
-	compressMagic byte = 0x01
-)
 
 // WIF contains the individual components described by the Wallet Import Format
 // (WIF).  A WIF string is typically used to represent a private key and its
@@ -56,35 +45,20 @@ type WIF struct {
 }
 
 // NewWIF creates a new WIF structure to export an address and its private key
-// as a string encoded in the Wallet Import Format.  The net argument must be
+// as a string encoded in the Wallet Import Format.  The compress argument
-// either btcwire.MainNet, btcwire.TestNet3 or btcwire.TestNet.  The compress
+// specifies whether the address intended to be imported or exported was created
-// argument specifies whether the address intended to be imported or exported
+// by serializing the public key compressed rather than uncompressed.
-// was created by serializing the public key compressed rather than
+func NewWIF(privKey *btcec.PrivateKey, net *btcnet.Params, compress bool) (*WIF, error) {
-// uncompressed.
+	if net == nil {
-func NewWIF(privKey *btcec.PrivateKey, net btcwire.BitcoinNet, compress bool) (*WIF, error) {
+		return nil, errors.New("no network")
-	// Determine the key's network identifier byte.  The same byte is
-	// shared for TestNet3 and TestNet (the regression test network).
-	switch net {
-	case btcwire.MainNet:
-		return &WIF{privKey, compress, mainNetKey}, nil
-	case btcwire.TestNet, btcwire.TestNet3:
-		return &WIF{privKey, compress, testNetKey}, nil
-	default:
-		return nil, ErrUnknownNet
 	}
+	return &WIF{privKey, compress, net.PrivateKeyID}, nil
 }
 
 // IsForNet returns whether or not the decoded WIF structure is associated
 // with the passed bitcoin network.
-func (w *WIF) IsForNet(net btcwire.BitcoinNet) bool {
+func (w *WIF) IsForNet(net *btcnet.Params) bool {
-	switch net {
+	return w.netID == net.PrivateKeyID
-	case btcwire.MainNet:
-		return w.netID == mainNetKey
-	case btcwire.TestNet, btcwire.TestNet3:
-		return w.netID == testNetKey
-	default:
-		return false
-	}
 }
 
 // DecodeWIF creates a new WIF structure by decoding the string encoding of
@@ -126,11 +100,6 @@ func DecodeWIF(wif string) (*WIF, error) {
 		return nil, ErrMalformedPrivateKey
 	}
 
-	netID := decoded[0]
-	if netID != mainNetKey && netID != testNetKey {
-		return nil, ErrUnknownNet
-	}
-
 	// Checksum is first four bytes of double SHA256 of the identifier byte
 	// and privKey.  Verify this matches the final 4 bytes of the decoded
 	// private key.
@@ -145,6 +114,7 @@ func DecodeWIF(wif string) (*WIF, error) {
 		return nil, ErrChecksumMismatch
 	}
 
+	netID := decoded[0]
 	privKeyBytes := decoded[1 : 1+btcec.PrivKeyBytesLen]
 	privKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), privKeyBytes)
 	return &WIF{privKey, compress, netID}, nil

wif_test.go

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