feat(handshake): lookup helper, primary network selection, simple getter functions (#403)

Signed-off-by: Akhil Repala <[email protected]>

Author: arepala-uml

internal/handshake/protocol/genesis/genesis-data.json

@@ -6,7 +6,25 @@ import (
 	"strings"
 )
 
-var raw []byte
+var raw = []byte(`{
+	"main": {
+	  "version": 0,
+	  "hash": "5b6ef2d3c1f3cdcadfd9a030ba1811efdd17740f14e166489760741d075992e0",
+	  "prev_block": "0000000000000000000000000000000000000000000000000000000000000000",
+	  "merkle_root": "8e4c9756fef2ad10375f360e0560fcc7587eb5223ddf8cd7c7e06e60a1140b15",
+	  "witness_root": "1a2c60b9439206938f8d7823782abdb8b211a57431e9c9b6a6365d8d42893351",
+	  "tree_root": "0000000000000000000000000000000000000000000000000000000000000000",
+	  "reserved_root": "0000000000000000000000000000000000000000000000000000000000000000",
+	  "time": 1580745078,
+	  "bits": "0x1c00ffff",
+	  "nonce": 0,
+	  "mask": "0000000000000000000000000000000000000000000000000000000000000000",
+	  "extra_nonce": "000000000000000000000000000000000000000000000000",
+	  "height": 0,
+	  "magic": 1533997779,
+	  "data_b64": "AAAAAHZBOF4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGixguUOSBpOPjXgjeCq9uLIRpXQx6cm2pjZdjUKJM1GOTJdW/vKtEDdfNg4FYPzHWH61Ij3fjNfH4G5goRQLFQAAAAD//wAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//////////AdBMV3cAAAAAABTwI3ri6Phg99eRJPxRPwEuWqqNIwAAAAAAAAQgULiTf8Xe8I+fPL2n5fCMcG7bgKuliAwAAAAAAAAAAAAgLV3lhgnUlw+1SPha0HqH20DgVONMyByVHKmVpY9nTbcgENdI7aG5xnuU0yROAhFndhiptLMp6JatkEMfn0gDS60g4sApmh5GZ3NRZlXwmmSx4WsleVMN5sSlnOVlTepFGA8="
+	}
+  }`)
 
 var (
 	Main     Net

internal/handshake/protocol/genesis/genesis.go

@@ -219,17 +219,6 @@ func bi(hex string) *big.Int {
 	return n
 }
 
-var Networks = map[NetworkType]*Network{
-	Mainnet: mainNet(),
-	Testnet: testNet(),
-	Regtest: regTest(),
-	Simnet:  simNet(),
-}
-
-func SelectNetwork(t NetworkType) *Network {
-	return Networks[t]
-}
-
 func testNet() *Network {
 	const (
 		targetSpacing = uint32(10 * 60)
@@ -634,3 +623,177 @@ func simNet() *Network {
 	// Need to implement
 	return &Network{}
 }
+
+var Networks = map[NetworkType]*Network{
+	Mainnet: mainNet(),
+	Testnet: testNet(),
+	Regtest: regTest(),
+	Simnet:  simNet(),
+}
+
+func SelectNetwork(t NetworkType) *Network {
+	return Networks[t]
+}
+
+var primary *Network
+
+// SetPrimary sets the default/primary network.
+func SetPrimary(t NetworkType) *Network {
+	n := SelectNetwork(t)
+	if n == nil {
+		panic("protocol: unknown network: " + string(t))
+	}
+	primary = n
+	return n
+}
+
+// Primary returns the default network and defaults to mainnet
+func Primary() *Network {
+	if primary == nil {
+		return SetPrimary(Mainnet)
+	}
+	return primary
+}
+
+// Get returns a network by type (nil if unknown)
+func Get(t NetworkType) *Network {
+	return SelectNetwork(t)
+}
+
+// Ensure returns n if known, else returns Primary()
+func Ensure(n *Network) *Network {
+	if n != nil {
+		return n
+	}
+	return Primary()
+}
+
+// Lookups helper functions
+
+// FromMagic finds a network by magic number.
+func FromMagic(magic uint32, prefer ...NetworkType) *Network {
+	if len(prefer) > 0 {
+		n := SelectNetwork(prefer[0])
+		if n != nil && n.Magic == magic {
+			return n
+		}
+		return nil
+	}
+	for _, n := range Networks {
+		if n != nil && n.Magic == magic {
+			return n
+		}
+	}
+	return nil
+}
+
+// FromWIF finds a network by WIF prefix.
+func FromWIF(prefix uint32, prefer ...NetworkType) *Network {
+	if len(prefer) > 0 {
+		n := SelectNetwork(prefer[0])
+		if n != nil && n.KeyPrefix.Privkey == prefix {
+			return n
+		}
+		return nil
+	}
+	for _, n := range Networks {
+		if n != nil && n.KeyPrefix.Privkey == prefix {
+			return n
+		}
+	}
+	return nil
+}
+
+// FromPublic finds a network by xpubkey prefix.
+func FromPublic(prefix uint32, prefer ...NetworkType) *Network {
+	if len(prefer) > 0 {
+		n := SelectNetwork(prefer[0])
+		if n != nil && n.KeyPrefix.XPubKey == prefix {
+			return n
+		}
+		return nil
+	}
+	for _, n := range Networks {
+		if n != nil && n.KeyPrefix.XPubKey == prefix {
+			return n
+		}
+	}
+	return nil
+}
+
+// FromPrivate finds a network by its xprivkey prefix.
+func FromPrivate(prefix uint32, prefer ...NetworkType) *Network {
+	if len(prefer) > 0 {
+		n := SelectNetwork(prefer[0])
+		if n != nil && n.KeyPrefix.XPrivKey == prefix {
+			return n
+		}
+		return nil
+	}
+	for _, n := range Networks {
+		if n != nil && n.KeyPrefix.XPrivKey == prefix {
+			return n
+		}
+	}
+	return nil
+}
+
+// FromPublic58 finds a network by its xpubkey base58 prefix.
+func FromPublic58(prefix string, prefer ...NetworkType) *Network {
+	if len(prefer) > 0 {
+		n := SelectNetwork(prefer[0])
+		if n != nil && n.KeyPrefix.XPubKey58 == prefix {
+			return n
+		}
+		return nil
+	}
+	for _, n := range Networks {
+		if n != nil && n.KeyPrefix.XPubKey58 == prefix {
+			return n
+		}
+	}
+	return nil
+}
+
+// FromPrivate58 finds a network by its xprivkey base58 prefix.
+func FromPrivate58(prefix string, prefer ...NetworkType) *Network {
+	if len(prefer) > 0 {
+		n := SelectNetwork(prefer[0])
+		if n != nil && n.KeyPrefix.XPrivKey58 == prefix {
+			return n
+		}
+		return nil
+	}
+	for _, n := range Networks {
+		if n != nil && n.KeyPrefix.XPrivKey58 == prefix {
+			return n
+		}
+	}
+	return nil
+}
+
+// FromAddress finds a network by its bech32 address prefix.
+func FromAddress(hrp string, prefer ...NetworkType) *Network {
+	if len(prefer) > 0 {
+		n := SelectNetwork(prefer[0])
+		if n != nil && n.AddressPrefix == hrp {
+			return n
+		}
+		return nil
+	}
+	for _, n := range Networks {
+		if n != nil && n.AddressPrefix == hrp {
+			return n
+		}
+	}
+	return nil
+}
+
+func (n *Network) String() string {
+	return n.Type
+}
+
+// Types lists all supported network type constants.
+func Types() []NetworkType {
+	return []NetworkType{Mainnet, Testnet, Regtest, Simnet}
+}