README

chaincfg

Build Status ISC License GoDoc

Package chaincfg defines chain configuration parameters for the three standard Bitcoin networks and provides the ability for callers to define their own custom Bitcoin networks.

Although this package was primarily written for bchd, it has intentionally been designed so it can be used as a standalone package for any projects needing to use parameters for the standard Bitcoin Cash networks or for projects needing to define their own network.

Sample Use

package main

import (
	"flag"
	"fmt"
	"log"

	"github.com/gcash/bchutil"
	"github.com/gcash/bchd/chaincfg"
)

var testnet = flag.Bool("testnet", false, "operate on the testnet Bitcoin network")

// By default (without -testnet), use mainnet.
var chainParams = &chaincfg.MainNetParams

func main() {
	flag.Parse()

	// Modify active network parameters if operating on testnet.
	if *testnet {
		chainParams = &chaincfg.TestNet3Params
	}

	// later...

	// Create and print new payment address, specific to the active network.
	pubKeyHash := make([]byte, 20)
	addr, err := bchutil.NewAddressPubKeyHash(pubKeyHash, chainParams)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(addr)
}

Installation and Updating

$ go get -u github.com/gcash/bchd/chaincfg

License

Package chaincfg is licensed under the copyfree ISC License.

Expand ▾ Collapse ▴

Documentation

Overview

    Package chaincfg defines chain configuration parameters.

    In addition to the main Bitcoin network, which is intended for the transfer of monetary value, there also exists two currently active standard networks: regression test and testnet (version 3). These networks are incompatible with each other (each sharing a different genesis block) and software should handle errors where input intended for one network is used on an application instance running on a different network.

    For library packages, chaincfg provides the ability to lookup chain parameters and encoding magics when passed a *Params. Older APIs not updated to the new convention of passing a *Params may lookup the parameters for a wire.BitcoinNet using ParamsForNet, but be aware that this usage is deprecated and will be removed from chaincfg in the future.

    For main packages, a (typically global) var may be assigned the address of one of the standard Param vars for use as the application's "active" network. When a network parameter is needed, it may then be looked up through this variable (either directly, or hidden in a library call).

    package main
    
    import (
            "flag"
            "fmt"
            "log"
    
            "github.com/gcash/bchutil"
            "github.com/gcash/bchd/chaincfg"
    )
    
    var testnet = flag.Bool("testnet", false, "operate on the testnet Bitcoin network")
    
    // By default (without -testnet), use mainnet.
    var chainParams = &chaincfg.MainNetParams
    
    func main() {
            flag.Parse()
    
            // Modify active network parameters if operating on testnet.
            if *testnet {
                    chainParams = &chaincfg.TestNet3Params
            }
    
            // later...
    
            // Create and print new payment address, specific to the active network.
            pubKeyHash := make([]byte, 20)
            addr, err := bchutil.NewAddressPubKeyHash(pubKeyHash, chainParams)
            if err != nil {
                    log.Fatal(err)
            }
            fmt.Println(addr)
    }
    

    If an application does not use one of the three standard Bitcoin networks, a new Params struct may be created which defines the parameters for the non-standard network. As a general rule of thumb, all network parameters should be unique to the network, but parameter collisions can still occur (unfortunately, this is the case with regtest and testnet3 sharing magics).

    Index

    Constants

    View Source
    const (
    	// DeploymentTestDummy defines the rule change deployment ID for testing
    	// purposes.
    	DeploymentTestDummy = iota
    
    	// DeploymentCSV defines the rule change deployment ID for the CSV
    	// soft-fork package. The CSV package includes the deployment of BIPS
    	// 68, 112, and 113.
    	DeploymentCSV
    
    	// DefinedDeployments is the number of currently defined deployments.
    	DefinedDeployments
    )

      Constants that define the deployment offset in the deployments field of the parameters for each deployment. This is useful to be able to get the details of a specific deployment by name.

      Variables

      View Source
      var (
      	// ErrDuplicateNet describes an error where the parameters for a Bitcoin
      	// network could not be set due to the network already being a standard
      	// network or previously-registered into this package.
      	ErrDuplicateNet = errors.New("duplicate Bitcoin network")
      
      	// ErrUnknownHDKeyID describes an error where the provided id which
      	// is intended to identify the network for a hierarchical deterministic
      	// private extended key is not registered.
      	ErrUnknownHDKeyID = errors.New("unknown hd private extended key bytes")
      )
      View Source
      var MainNetParams = Params{
      	Name:        "mainnet",
      	Net:         wire.MainNet,
      	DefaultPort: "8333",
      	DNSSeeds: []DNSSeed{
      		{"seed.bchd.cash", true},
      		{"btccash-seeder.bitcoinunlimited.info", true},
      		{"seed-bch.bitcoinforks.org", true},
      		{"seed.bch.loping.net", true},
      		{"dnsseed.electroncash.de", true},
      	},
      
      	GenesisBlock:  &genesisBlock,
      	GenesisHash:   &genesisHash,
      	PowLimit:      mainPowLimit,
      	PowLimitBits:  0x1d00ffff,
      	BIP0034Height: 227931,
      	BIP0065Height: 388381,
      	BIP0066Height: 363725,
      
      	UahfForkHeight:              478558,
      	DaaForkHeight:               504031,
      	MagneticAnonomalyForkHeight: 556766,
      	GreatWallForkHeight:         582679,
      	GravitonForkHeight:          609135,
      	PhononForkHeight:            635258,
      	AxionActivationHeight:       661647,
      
      	CoinbaseMaturity:                     100,
      	SubsidyReductionInterval:             210000,
      	TargetTimespan:                       time.Hour * 24 * 14,
      	TargetTimePerBlock:                   time.Minute * 10,
      	RetargetAdjustmentFactor:             4,
      	ReduceMinDifficulty:                  false,
      	NoDifficultyAdjustment:               false,
      	MinDiffReductionTime:                 0,
      	AsertDifficultyHalflife:              2 * 24 * 3600,
      	AsertDifficultyAnchorHeight:          661647,
      	AsertDifficultyAnchorParentTimestamp: 1605447844,
      	AsertDifficultyAnchorBits:            402971390,
      	GenerateSupported:                    false,
      
      	Checkpoints: []Checkpoint{
      		{Height: 11111, Hash: newHashFromStr("0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d")},
      		{Height: 33333, Hash: newHashFromStr("000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6")},
      		{Height: 74000, Hash: newHashFromStr("0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20")},
      		{Height: 105000, Hash: newHashFromStr("00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97")},
      		{Height: 134444, Hash: newHashFromStr("00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe")},
      		{Height: 168000, Hash: newHashFromStr("000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763")},
      		{Height: 193000, Hash: newHashFromStr("000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317")},
      		{Height: 210000, Hash: newHashFromStr("000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e")},
      		{Height: 216116, Hash: newHashFromStr("00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e")},
      		{Height: 225430, Hash: newHashFromStr("00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932")},
      		{Height: 250000, Hash: newHashFromStr("000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214")},
      		{Height: 267300, Hash: newHashFromStr("000000000000000a83fbd660e918f218bf37edd92b748ad940483c7c116179ac")},
      		{Height: 279000, Hash: newHashFromStr("0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40")},
      		{Height: 300255, Hash: newHashFromStr("0000000000000000162804527c6e9b9f0563a280525f9d08c12041def0a0f3b2")},
      		{Height: 319400, Hash: newHashFromStr("000000000000000021c6052e9becade189495d1c539aa37c58917305fd15f13b")},
      		{Height: 343185, Hash: newHashFromStr("0000000000000000072b8bf361d01a6ba7d445dd024203fafc78768ed4368554")},
      		{Height: 352940, Hash: newHashFromStr("000000000000000010755df42dba556bb72be6a32f3ce0b6941ce4430152c9ff")},
      		{Height: 382320, Hash: newHashFromStr("00000000000000000a8dc6ed5b133d0eb2fd6af56203e4159789b092defd8ab2")},
      		{Height: 400000, Hash: newHashFromStr("000000000000000004ec466ce4732fe6f1ed1cddc2ed4b328fff5224276e3f6f")},
      		{Height: 430000, Hash: newHashFromStr("000000000000000001868b2bb3a285f3cc6b33ea234eb70facf4dcdf22186b87")},
      		{Height: 470000, Hash: newHashFromStr("0000000000000000006c539c722e280a0769abd510af0073430159d71e6d7589")},
      		{Height: 510000, Hash: newHashFromStr("00000000000000000367922b6457e21d591ef86b360d78a598b14c2f1f6b0e04")},
      		{Height: 552979, Hash: newHashFromStr("0000000000000000015648768ac1b788a83187d706f858919fcc5c096b76fbf2")},
      		{
      			Height:      556767,
      			Hash:        newHashFromStr("0000000000000000004626ff6e3b936941d341c5932ece4357eeccac44e6d56c"),
      			UtxoSetHash: newHashFromStr("352a96fdd4dd229ced594b6bae5c658da514eb76e9b04eb469a7effaada6a14e"),
      			UtxoSetSize: 3102076686,
      			UtxoSetSources: []string{
      				"http://localhost:8080/ipfs/QmQECm1yUgKh7oQg2syCFo5BLvhFSSH9m95fw41b3GTrXV",
      				"https://ipfs.greyh.at/ipfs/QmQECm1yUgKh7oQg2syCFo5BLvhFSSH9m95fw41b3GTrXV",
      				"https://ipfs.io/ipfs/QmQECm1yUgKh7oQg2syCFo5BLvhFSSH9m95fw41b3GTrXV",
      			},
      		},
      		{
      			Height:      582680,
      			Hash:        newHashFromStr("000000000000000001b4b8e36aec7d4f9671a47872cb9a74dc16ca398c7dcc18"),
      			UtxoSetHash: newHashFromStr("2406189cf8e15140c2004d4e9aa012711f48183689a305223c9bafdd3af8887e"),
      			UtxoSetSize: 3178882199,
      			UtxoSetSources: []string{
      				"http://localhost:8080/ipfs/QmXkBQJrMKkCKNbwv4m5xtnqwU9Sq7kucPigvZW8mWxcrv",
      				"https://ipfs.greyh.at/ipfs/QmXkBQJrMKkCKNbwv4m5xtnqwU9Sq7kucPigvZW8mWxcrv",
      				"https://ipfs.io/ipfs/QmXkBQJrMKkCKNbwv4m5xtnqwU9Sq7kucPigvZW8mWxcrv",
      			},
      		},
      		{
      			Height:      609136,
      			Hash:        newHashFromStr("000000000000000000b48bb207faac5ac655c313e41ac909322eaa694f5bc5b1"),
      			UtxoSetHash: newHashFromStr("105b794be6370014bef629b61db50716eea29e2d6c712e11cad9fa9c2aaeee30"),
      			UtxoSetSize: 3214790044,
      			UtxoSetSources: []string{
      				"http://localhost:8080/ipfs/QmZQFi5kiY1cAu6hEpLCEaAZ3FX1CtmFVtE8DiLvkYNg62",
      				"https://ipfs.greyh.at/ipfs/QmZQFi5kiY1cAu6hEpLCEaAZ3FX1CtmFVtE8DiLvkYNg62",
      				"https://ipfs.io/ipfs/QmZQFi5kiY1cAu6hEpLCEaAZ3FX1CtmFVtE8DiLvkYNg62",
      			},
      		},
      		{
      			Height:      635259,
      			Hash:        newHashFromStr("00000000000000000033dfef1fc2d6a5d5520b078c55193a9bf498c5b27530f7"),
      			UtxoSetHash: newHashFromStr("45dc882e48bf4b6d894db29512f35296ffda5ea32c2b82920aa5ae1ba056689a"),
      			UtxoSetSize: 3282796875,
      			UtxoSetSources: []string{
      				"http://localhost:8080/ipfs/QmYhcrsLgGfRTuxoZUCPCEj5xzZx5sAgV32Z7p1qPerJBr",
      				"https://ipfs.greyh.at/ipfs/QmYhcrsLgGfRTuxoZUCPCEj5xzZx5sAgV32Z7p1qPerJBr",
      				"https://ipfs.io/ipfs/QmYhcrsLgGfRTuxoZUCPCEj5xzZx5sAgV32Z7p1qPerJBr",
      			},
      		},
      		{
      			Height:      661648,
      			Hash:        newHashFromStr("0000000000000000029e471c41818d24b8b74c911071c4ef0b4a0509f9b5a8ce"),
      			UtxoSetHash: newHashFromStr("fff228b2f788d2be35868fc2517d2557f856cbb9d6e2dad7310ab6054a29ef67"),
      			UtxoSetSize: 2931107971,
      			UtxoSetSources: []string{
      				"http://localhost:8080/ipfs/QmY9Anst9NB42RVSGZehNCF52B2DxAzAYXEPrLrar75VMT",
      				"https://ipfs.greyh.at/ipfs/QmY9Anst9NB42RVSGZehNCF52B2DxAzAYXEPrLrar75VMT",
      				"https://ipfs.io/ipfs/QmY9Anst9NB42RVSGZehNCF52B2DxAzAYXEPrLrar75VMT",
      			},
      		},
      	},
      
      	RuleChangeActivationThreshold: 1916,
      	MinerConfirmationWindow:       2016,
      	Deployments: [DefinedDeployments]ConsensusDeployment{
      		DeploymentTestDummy: {
      			BitNumber:  28,
      			StartTime:  1199145601,
      			ExpireTime: 1230767999,
      		},
      		DeploymentCSV: {
      			BitNumber:  0,
      			StartTime:  1462060800,
      			ExpireTime: 1493596800,
      		},
      	},
      
      	RelayNonStdTxs: false,
      
      	CashAddressPrefix: "bitcoincash",
      
      	LegacyPubKeyHashAddrID: 0x00,
      	LegacyScriptHashAddrID: 0x05,
      	PrivateKeyID:           0x80,
      
      	HDPrivateKeyID: [4]byte{0x04, 0x88, 0xad, 0xe4},
      	HDPublicKeyID:  [4]byte{0x04, 0x88, 0xb2, 0x1e},
      
      	HDCoinType: 145,
      }

        MainNetParams defines the network parameters for the main Bitcoin network.

        View Source
        var RegressionNetParams = Params{
        	Name:        "regtest",
        	Net:         wire.TestNet,
        	DefaultPort: "18444",
        	DNSSeeds:    []DNSSeed{},
        
        	GenesisBlock:     &regTestGenesisBlock,
        	GenesisHash:      &regTestGenesisHash,
        	PowLimit:         regressionPowLimit,
        	PowLimitBits:     0x207fffff,
        	CoinbaseMaturity: 100,
        	BIP0034Height:    100000000,
        	BIP0065Height:    1351,
        	BIP0066Height:    1251,
        
        	UahfForkHeight:              0,
        	DaaForkHeight:               0,
        	MagneticAnonomalyForkHeight: 1000,
        	PhononForkHeight:            1000,
        	AxionActivationHeight:       0,
        
        	SubsidyReductionInterval:             150,
        	TargetTimespan:                       time.Hour * 24 * 14,
        	TargetTimePerBlock:                   time.Minute * 10,
        	RetargetAdjustmentFactor:             4,
        	ReduceMinDifficulty:                  true,
        	NoDifficultyAdjustment:               true,
        	MinDiffReductionTime:                 time.Minute * 20,
        	AsertDifficultyHalflife:              3600,
        	AsertDifficultyAnchorHeight:          0,
        	AsertDifficultyAnchorParentTimestamp: regTestGenesisBlock.Header.Timestamp.Unix(),
        	AsertDifficultyAnchorBits:            regTestGenesisBlock.Header.Bits,
        	GenerateSupported:                    true,
        
        	Checkpoints: nil,
        
        	RuleChangeActivationThreshold: 108,
        	MinerConfirmationWindow:       144,
        	Deployments: [DefinedDeployments]ConsensusDeployment{
        		DeploymentTestDummy: {
        			BitNumber:  28,
        			StartTime:  0,
        			ExpireTime: math.MaxInt64,
        		},
        		DeploymentCSV: {
        			BitNumber:  0,
        			StartTime:  0,
        			ExpireTime: math.MaxInt64,
        		},
        	},
        
        	RelayNonStdTxs: true,
        
        	CashAddressPrefix: "bchreg",
        
        	LegacyPubKeyHashAddrID: 0x6f,
        	LegacyScriptHashAddrID: 0xc4,
        	PrivateKeyID:           0xef,
        
        	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
        	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},
        
        	HDCoinType: 1,
        }

          RegressionNetParams defines the network parameters for the regression test Bitcoin network. Not to be confused with the test Bitcoin network (version 3), this network is sometimes simply called "testnet".

          View Source
          var SimNetParams = Params{
          	Name:        "simnet",
          	Net:         wire.SimNet,
          	DefaultPort: "18555",
          	DNSSeeds:    []DNSSeed{},
          
          	GenesisBlock:                         &simNetGenesisBlock,
          	GenesisHash:                          &simNetGenesisHash,
          	PowLimit:                             simNetPowLimit,
          	PowLimitBits:                         0x207fffff,
          	BIP0034Height:                        0,
          	BIP0065Height:                        0,
          	BIP0066Height:                        0,
          	UahfForkHeight:                       0,
          	DaaForkHeight:                        2000,
          	MagneticAnonomalyForkHeight:          3000,
          	GreatWallForkHeight:                  0,
          	AxionActivationHeight:                4000,
          	CoinbaseMaturity:                     100,
          	SubsidyReductionInterval:             210000,
          	TargetTimespan:                       time.Hour * 24 * 14,
          	TargetTimePerBlock:                   time.Minute * 10,
          	RetargetAdjustmentFactor:             4,
          	ReduceMinDifficulty:                  true,
          	NoDifficultyAdjustment:               true,
          	MinDiffReductionTime:                 time.Minute * 20,
          	AsertDifficultyHalflife:              3600,
          	AsertDifficultyAnchorHeight:          0,
          	AsertDifficultyAnchorParentTimestamp: simNetGenesisBlock.Header.Timestamp.Unix(),
          	AsertDifficultyAnchorBits:            simNetGenesisBlock.Header.Bits,
          	GenerateSupported:                    true,
          
          	Checkpoints: nil,
          
          	RuleChangeActivationThreshold: 75,
          	MinerConfirmationWindow:       100,
          	Deployments: [DefinedDeployments]ConsensusDeployment{
          		DeploymentTestDummy: {
          			BitNumber:  28,
          			StartTime:  0,
          			ExpireTime: math.MaxInt64,
          		},
          		DeploymentCSV: {
          			BitNumber:  0,
          			StartTime:  0,
          			ExpireTime: math.MaxInt64,
          		},
          	},
          
          	RelayNonStdTxs: true,
          
          	CashAddressPrefix: "bchsim",
          
          	LegacyPubKeyHashAddrID: 0x3f,
          	LegacyScriptHashAddrID: 0x7b,
          	PrivateKeyID:           0x64,
          
          	HDPrivateKeyID: [4]byte{0x04, 0x20, 0xb9, 0x00},
          	HDPublicKeyID:  [4]byte{0x04, 0x20, 0xbd, 0x3a},
          
          	HDCoinType: 115,
          }

            SimNetParams defines the network parameters for the simulation test Bitcoin network. This network is similar to the normal test network except it is intended for private use within a group of individuals doing simulation testing. The functionality is intended to differ in that the only nodes which are specifically specified are used to create the network rather than following normal discovery rules. This is important as otherwise it would just turn into another public testnet.

            View Source
            var TestNet3Params = Params{
            	Name:        "testnet3",
            	Net:         wire.TestNet3,
            	DefaultPort: "18333",
            	DNSSeeds: []DNSSeed{
            		{"testnet-seed.bchd.cash", true},
            		{"testnet-seed-bch.bitcoinforks.org", true},
            		{"seed.tbch.loping.net", true},
            	},
            
            	GenesisBlock:  &testNet3GenesisBlock,
            	GenesisHash:   &testNet3GenesisHash,
            	PowLimit:      testNet3PowLimit,
            	PowLimitBits:  0x1d00ffff,
            	BIP0034Height: 21111,
            	BIP0065Height: 581885,
            	BIP0066Height: 330776,
            
            	UahfForkHeight:              1155875,
            	DaaForkHeight:               1188697,
            	MagneticAnonomalyForkHeight: 1267996,
            	GreatWallForkHeight:         1303884,
            	GravitonForkHeight:          1341711,
            	PhononForkHeight:            1378460,
            	AxionActivationHeight:       1421481,
            
            	CoinbaseMaturity:                     100,
            	SubsidyReductionInterval:             210000,
            	TargetTimespan:                       time.Hour * 24 * 14,
            	TargetTimePerBlock:                   time.Minute * 10,
            	RetargetAdjustmentFactor:             4,
            	ReduceMinDifficulty:                  true,
            	NoDifficultyAdjustment:               false,
            	MinDiffReductionTime:                 time.Minute * 20,
            	AsertDifficultyHalflife:              3600,
            	AsertDifficultyAnchorHeight:          1421481,
            	AsertDifficultyAnchorParentTimestamp: 1605445400,
            	AsertDifficultyAnchorBits:            486604799,
            	GenerateSupported:                    false,
            
            	Checkpoints: []Checkpoint{
            		{Height: 546, Hash: newHashFromStr("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},
            		{Height: 100000, Hash: newHashFromStr("00000000009e2958c15ff9290d571bf9459e93b19765c6801ddeccadbb160a1e")},
            		{Height: 200000, Hash: newHashFromStr("0000000000287bffd321963ef05feab753ebe274e1d78b2fd4e2bfe9ad3aa6f2")},
            		{Height: 300001, Hash: newHashFromStr("0000000000004829474748f3d1bc8fcf893c88be255e6d7f571c548aff57abf4")},
            		{Height: 400002, Hash: newHashFromStr("0000000005e2c73b8ecb82ae2dbc2e8274614ebad7172b53528aba7501f5a089")},
            		{Height: 500011, Hash: newHashFromStr("00000000000929f63977fbac92ff570a9bd9e7715401ee96f2848f7b07750b02")},
            		{Height: 600002, Hash: newHashFromStr("000000000001f471389afd6ee94dcace5ccc44adc18e8bff402443f034b07240")},
            		{Height: 700000, Hash: newHashFromStr("000000000000406178b12a4dea3b27e13b3c4fe4510994fd667d7c1e6a3f4dc1")},
            		{Height: 800010, Hash: newHashFromStr("000000000017ed35296433190b6829db01e657d80631d43f5983fa403bfdb4c1")},
            		{Height: 900000, Hash: newHashFromStr("0000000000356f8d8924556e765b7a94aaebc6b5c8685dcfa2b1ee8b41acd89b")},
            		{Height: 1000007, Hash: newHashFromStr("00000000001ccb893d8a1f25b70ad173ce955e5f50124261bbbc50379a612ddf")},
            		{Height: 1341712, Hash: newHashFromStr("00000000fffc44ea2e202bd905a9fbbb9491ef9e9d5a9eed4039079229afa35b")},
            		{Height: 1378461, Hash: newHashFromStr("0000000099f5509b5f36b1926bcf82b21d936ebeadee811030dfbbb7fae915d7")},
            		{Height: 1421482, Hash: newHashFromStr("0000000023e0680a8a062b3cc289a4a341124ce7fcb6340ede207e194d73b60a")},
            	},
            
            	RuleChangeActivationThreshold: 1512,
            	MinerConfirmationWindow:       2016,
            	Deployments: [DefinedDeployments]ConsensusDeployment{
            		DeploymentTestDummy: {
            			BitNumber:  28,
            			StartTime:  1199145601,
            			ExpireTime: 1230767999,
            		},
            		DeploymentCSV: {
            			BitNumber:  0,
            			StartTime:  1456790400,
            			ExpireTime: 1493596800,
            		},
            	},
            
            	RelayNonStdTxs: true,
            
            	CashAddressPrefix: "bchtest",
            
            	LegacyPubKeyHashAddrID: 0x6f,
            	LegacyScriptHashAddrID: 0xc4,
            	PrivateKeyID:           0xef,
            
            	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
            	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},
            
            	HDCoinType: 1,
            }

              TestNet3Params defines the network parameters for the test Bitcoin network (version 3). Not to be confused with the regression test network, this network is sometimes simply called "testnet".

              Functions

              func HDPrivateKeyToPublicKeyID

              func HDPrivateKeyToPublicKeyID(id []byte) ([]byte, error)

                HDPrivateKeyToPublicKeyID accepts a private hierarchical deterministic extended key id and returns the associated public key id. When the provided id is not registered, the ErrUnknownHDKeyID error will be returned.

                func IsCashAddressPrefix

                func IsCashAddressPrefix(prefix string) bool

                  IsCashAddressPrefix returns whether the prefix is a known prefix for the cashaddress on any default or registered network. This is used when decoding an address string into a specific address type.

                  func IsPubKeyHashAddrID

                  func IsPubKeyHashAddrID(id byte) bool

                    IsPubKeyHashAddrID returns whether the id is an identifier known to prefix a pay-to-pubkey-hash address on any default or registered network. This is used when decoding an address string into a specific address type. It is up to the caller to check both this and IsScriptHashAddrID and decide whether an address is a pubkey hash address, script hash address, neither, or undeterminable (if both return true).

                    func IsScriptHashAddrID

                    func IsScriptHashAddrID(id byte) bool

                      IsScriptHashAddrID returns whether the id is an identifier known to prefix a pay-to-script-hash address on any default or registered network. This is used when decoding an address string into a specific address type. It is up to the caller to check both this and IsPubKeyHashAddrID and decide whether an address is a pubkey hash address, script hash address, neither, or undeterminable (if both return true).

                      func Register

                      func Register(params *Params) error

                        Register registers the network parameters for a Bitcoin network. This may error with ErrDuplicateNet if the network is already registered (either due to a previous Register call, or the network being one of the default networks).

                        Network parameters should be registered into this package by a main package as early as possible. Then, library packages may lookup networks or network parameters based on inputs and work regardless of the network being standard or not.

                        Types

                        type Checkpoint

                        type Checkpoint struct {
                        	Height         int32
                        	Hash           *chainhash.Hash
                        	UtxoSetHash    *chainhash.Hash
                        	UtxoSetSources []string
                        	UtxoSetSize    uint32
                        }

                          Checkpoint identifies a known good point in the block chain. Using checkpoints allows a few optimizations for old blocks during initial download and also prevents forks from old blocks.

                          Each checkpoint is selected based upon several factors. See the documentation for blockchain.IsCheckpointCandidate for details on the selection criteria.

                          type ConsensusDeployment

                          type ConsensusDeployment struct {
                          	// BitNumber defines the specific bit number within the block version
                          	// this particular soft-fork deployment refers to.
                          	BitNumber uint8
                          
                          	// StartTime is the median block time after which voting on the
                          	// deployment starts.
                          	StartTime uint64
                          
                          	// ExpireTime is the median block time after which the attempted
                          	// deployment expires.
                          	ExpireTime uint64
                          }

                            ConsensusDeployment defines details related to a specific consensus rule change that is voted in. This is part of BIP0009.

                            type DNSSeed

                            type DNSSeed struct {
                            	// Host defines the hostname of the seed.
                            	Host string
                            
                            	// HasFiltering defines whether the seed supports filtering
                            	// by service flags (wire.ServiceFlag).
                            	HasFiltering bool
                            }

                              DNSSeed identifies a DNS seed.

                              func (DNSSeed) String

                              func (d DNSSeed) String() string

                                String returns the hostname of the DNS seed in human-readable form.

                                type Params

                                type Params struct {
                                	// Name defines a human-readable identifier for the network.
                                	Name string
                                
                                	// Net defines the magic bytes used to identify the network.
                                	Net wire.BitcoinNet
                                
                                	// DefaultPort defines the default peer-to-peer port for the network.
                                	DefaultPort string
                                
                                	// DNSSeeds defines a list of DNS seeds for the network that are used
                                	// as one method to discover peers.
                                	DNSSeeds []DNSSeed
                                
                                	// GenesisBlock defines the first block of the chain.
                                	GenesisBlock *wire.MsgBlock
                                
                                	// GenesisHash is the starting block hash.
                                	GenesisHash *chainhash.Hash
                                
                                	// PowLimit defines the highest allowed proof of work value for a block
                                	// as a uint256.
                                	PowLimit *big.Int
                                
                                	// PowLimitBits defines the highest allowed proof of work value for a
                                	// block in compact form.
                                	PowLimitBits uint32
                                
                                	// These fields define the block heights at which the specified softfork
                                	// BIP became active.
                                	BIP0034Height int32
                                	BIP0065Height int32
                                	BIP0066Height int32
                                
                                	// The following are the heights at which the Bitcoin Cash specific forks
                                	// became active.
                                	UahfForkHeight              int32 // August 1, 2017 hardfork
                                	DaaForkHeight               int32 // November 13, 2017 hardfork
                                	MagneticAnonomalyForkHeight int32 // November 15, 2018 hardfork
                                	GreatWallForkHeight         int32 // May 15, 2019 hardfork
                                	GravitonForkHeight          int32 // Nov 15, 2019 hardfork
                                	PhononForkHeight            int32 // May 15, 2020 hardfork
                                	AxionActivationHeight       int32 // Nov 15, 2020 hardfork
                                
                                	// CoinbaseMaturity is the number of blocks required before newly mined
                                	// coins (coinbase transactions) can be spent.
                                	CoinbaseMaturity uint16
                                
                                	// SubsidyReductionInterval is the interval of blocks before the subsidy
                                	// is reduced.
                                	SubsidyReductionInterval int32
                                
                                	// TargetTimespan is the desired amount of time that should elapse
                                	// before the block difficulty requirement is examined to determine how
                                	// it should be changed in order to maintain the desired block
                                	// generation rate.
                                	TargetTimespan time.Duration
                                
                                	// TargetTimePerBlock is the desired amount of time to generate each
                                	// block.
                                	TargetTimePerBlock time.Duration
                                
                                	// RetargetAdjustmentFactor is the adjustment factor used to limit
                                	// the minimum and maximum amount of adjustment that can occur between
                                	// difficulty retargets.
                                	RetargetAdjustmentFactor int64
                                
                                	// ReduceMinDifficulty defines whether the network should reduce the
                                	// minimum required difficulty after a long enough period of time has
                                	// passed without finding a block.  This is really only useful for test
                                	// networks and should not be set on a main network.
                                	ReduceMinDifficulty bool
                                
                                	// NoDifficultyAdjustment defines whether the network should skip the
                                	// normal difficulty adjustment and keep the current difficulty.
                                	NoDifficultyAdjustment bool
                                
                                	// MinDiffReductionTime is the amount of time after which the minimum
                                	// required difficulty should be reduced when a block hasn't been found.
                                	//
                                	// NOTE: This only applies if ReduceMinDifficulty is true.
                                	MinDiffReductionTime time.Duration
                                
                                	// AsertDifficultyHalflife is the halflife parameter used by the asert
                                	// difficulty adjustment algorithm for the given network.
                                	AsertDifficultyHalflife int64
                                
                                	// AsertDifficultyAnchorHeight is the height of the asert difficulty
                                	// anchor block.
                                	AsertDifficultyAnchorHeight int32
                                
                                	// AsertDifficultyAnchorParentTimestamp is the timestamp of the asert difficulty
                                	// anchor block's parent.
                                	AsertDifficultyAnchorParentTimestamp int64
                                
                                	// AsertDifficultyAnchorBits is the bits of the asert difficulty
                                	// anchor block.
                                	AsertDifficultyAnchorBits uint32
                                
                                	// GenerateSupported specifies whether or not CPU mining is allowed.
                                	GenerateSupported bool
                                
                                	// Checkpoints ordered from oldest to newest.
                                	Checkpoints []Checkpoint
                                
                                	// These fields are related to voting on consensus rule changes as
                                	// defined by BIP0009.
                                	//
                                	// RuleChangeActivationThreshold is the number of blocks in a threshold
                                	// state retarget window for which a positive vote for a rule change
                                	// must be cast in order to lock in a rule change. It should typically
                                	// be 95% for the main network and 75% for test networks.
                                	//
                                	// MinerConfirmationWindow is the number of blocks in each threshold
                                	// state retarget window.
                                	//
                                	// Deployments define the specific consensus rule changes to be voted
                                	// on.
                                	RuleChangeActivationThreshold uint32
                                	MinerConfirmationWindow       uint32
                                	Deployments                   [DefinedDeployments]ConsensusDeployment
                                
                                	// Mempool parameters
                                	RelayNonStdTxs bool
                                
                                	// The prefix used for the cashaddress. This is different for each network.
                                	CashAddressPrefix string
                                
                                	// Address encoding magics
                                	LegacyPubKeyHashAddrID byte // First byte of a P2PKH address
                                	LegacyScriptHashAddrID byte // First byte of a P2SH address
                                	PrivateKeyID           byte // First byte of a WIF private key
                                
                                	// BIP32 hierarchical deterministic extended key magics
                                	HDPrivateKeyID [4]byte
                                	HDPublicKeyID  [4]byte
                                
                                	// BIP44 coin type used in the hierarchical deterministic path for
                                	// address generation.
                                	HDCoinType uint32
                                }

                                  Params defines a Bitcoin network by its parameters. These parameters may be used by Bitcoin applications to differentiate networks as well as addresses and keys for one network from those intended for use on another network.

                                  Directories

                                  Path Synopsis
                                  Package chainhash provides abstracted hash functionality.
                                  Package chainhash provides abstracted hash functionality.