coinparam

package
v0.0.0-...-aeb2f35 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 12, 2018 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

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")

	// ErrUnknownPrefix describes and error where the provided prefix string
	// isn't found associated with a parameter set / HDCoinType
	ErrUnknownPrefix = errors.New("unknown bech32 prefix")
)
View Source 
var BC2NetParams = Params{
	Name:          "bc2",
	NetMagicBytes: 0xcaa5afea,
	DefaultPort:   "8444",
	DNSSeeds:      []string{},

	GenesisBlock: &bc2GenesisBlock,
	GenesisHash:  &bc2GenesisHash,
	PoWFunction: func(b []byte, height int32) chainhash.Hash {
		return chainhash.DoubleHashH(b)
	},
	DiffCalcFunction:         diffBitcoin,
	FeePerByte:               80,
	PowLimit:                 bc2NetPowLimit,
	PowLimitBits:             0x1d7fffff,
	CoinbaseMaturity:         10,
	SubsidyReductionInterval: 210000,
	TargetTimespan:           time.Hour * 1,
	TargetTimePerBlock:       time.Minute * 1,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      false,
	MinDiffReductionTime:     time.Minute * 20,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{},

	BlockEnforceNumRequired: 51,
	BlockRejectNumRequired:  75,
	BlockUpgradeNumToCheck:  100,

	RelayNonStdTxs: true,

	PubKeyHashAddrID: 0x19,
	ScriptHashAddrID: 0x1c,
	Bech32Prefix:     "bc2",
	PrivateKeyID:     0xef,

	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},

	HDCoinType: 2,

	TestCoin: true,
}

BC2NetParams are the parameters for the BC2 test network.

View Source 
var BitcoinParams = Params{
	Name:          "bitcoin",
	NetMagicBytes: 0xd9b4bef9,
	DefaultPort:   "8333",
	DNSSeeds: []string{
		"seed.bitcoin.sipa.be",
		"dnsseed.bluematt.me",
		"dnsseed.bitcoin.dashjr.org",
		"seed.bitcoinstats.com",
		"seed.bitnodes.io",
		"bitseed.xf2.org",
		"seed.bitcoin.jonasschnelli.ch",
	},

	GenesisBlock: &genesisBlock,
	GenesisHash:  &genesisHash,
	PoWFunction: func(b []byte, height int32) chainhash.Hash {
		return chainhash.DoubleHashH(b)
	},
	DiffCalcFunction:         diffBitcoin,
	FeePerByte:               80,
	PowLimit:                 mainPowLimit,
	PowLimitBits:             0x1d00ffff,
	CoinbaseMaturity:         100,
	SubsidyReductionInterval: 210000,
	TargetTimespan:           time.Hour * 24 * 14,
	TargetTimePerBlock:       time.Minute * 10,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      false,
	MinDiffReductionTime:     0,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{
		{11111, newHashFromStr("0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d")},
		{33333, newHashFromStr("000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6")},
		{74000, newHashFromStr("0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20")},
		{105000, newHashFromStr("00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97")},
		{134444, newHashFromStr("00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe")},
		{168000, newHashFromStr("000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763")},
		{193000, newHashFromStr("000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317")},
		{210000, newHashFromStr("000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e")},
		{216116, newHashFromStr("00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e")},
		{225430, newHashFromStr("00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932")},
		{250000, newHashFromStr("000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214")},
		{267300, newHashFromStr("000000000000000a83fbd660e918f218bf37edd92b748ad940483c7c116179ac")},
		{279000, newHashFromStr("0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40")},
		{300255, newHashFromStr("0000000000000000162804527c6e9b9f0563a280525f9d08c12041def0a0f3b2")},
		{319400, newHashFromStr("000000000000000021c6052e9becade189495d1c539aa37c58917305fd15f13b")},
		{343185, newHashFromStr("0000000000000000072b8bf361d01a6ba7d445dd024203fafc78768ed4368554")},
		{352940, newHashFromStr("000000000000000010755df42dba556bb72be6a32f3ce0b6941ce4430152c9ff")},
		{382320, newHashFromStr("00000000000000000a8dc6ed5b133d0eb2fd6af56203e4159789b092defd8ab2")},
	},

	BlockEnforceNumRequired: 750,
	BlockRejectNumRequired:  950,
	BlockUpgradeNumToCheck:  1000,

	RelayNonStdTxs: false,

	PubKeyHashAddrID: 0x00,
	ScriptHashAddrID: 0x05,
	PrivateKeyID:     0x80,
	Bech32Prefix:     "bc",

	HDPrivateKeyID: [4]byte{0x04, 0x88, 0xad, 0xe4},
	HDPublicKeyID:  [4]byte{0x04, 0x88, 0xb2, 0x1e},

	HDCoinType: 0,
}

MainNetParams defines the network parameters for the main Bitcoin network.

View Source 
var LiteCoinTestNet4Params = Params{
	Name:          "litetest4",
	NetMagicBytes: 0xf1c8d2fd,
	DefaultPort:   "19335",
	DNSSeeds: []string{
		"testnet-seed.litecointools.com",
		"seed-b.litecoin.loshan.co.uk",
		"dnsseed-testnet.thrasher.io",
	},

	GenesisBlock: &bc2GenesisBlock,
	GenesisHash:  &liteCoinTestNet4GenesisHash,
	PoWFunction: func(b []byte, height int32) chainhash.Hash {
		scryptBytes, _ := scrypt.Key(b, b, 1024, 1, 1, 32)
		asChainHash, _ := chainhash.NewHash(scryptBytes)
		return *asChainHash
	},
	DiffCalcFunction: diffBitcoin,
	StartHeader: [80]byte{
		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0xd9, 0xce, 0xd4, 0xed, 0x11, 0x30, 0xf7, 0xb7, 0xfa, 0xad, 0x9b, 0xe2,
		0x53, 0x23, 0xff, 0xaf, 0xa3, 0x32, 0x32, 0xa1, 0x7c, 0x3e, 0xdf, 0x6c,
		0xfd, 0x97, 0xbe, 0xe6, 0xba, 0xfb, 0xdd, 0x97, 0xf6, 0x0b, 0xa1, 0x58,
		0xf0, 0xff, 0x0f, 0x1e, 0xe1, 0x79, 0x04, 0x00,
	},
	StartHeight:              48384,
	AssumeDiffBefore:         50401,
	FeePerByte:               800,
	PowLimit:                 liteCoinTestNet4PowLimit,
	PowLimitBits:             0x1e0fffff,
	CoinbaseMaturity:         100,
	SubsidyReductionInterval: 840000,
	TargetTimespan:           time.Hour * 84,
	TargetTimePerBlock:       time.Second * 150,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      true,
	MinDiffReductionTime:     time.Minute * 10,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{},

	BlockEnforceNumRequired: 51,
	BlockRejectNumRequired:  75,
	BlockUpgradeNumToCheck:  100,

	RelayNonStdTxs: true,

	PubKeyHashAddrID: 0x6f,
	ScriptHashAddrID: 0xc4,
	Bech32Prefix:     "tltc",
	PrivateKeyID:     0xef,

	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},

	HDCoinType: 65537,
}

LiteCoinTestNet4Params are the parameters for the litecoin test network 4.

View Source 
var LiteRegNetParams = Params{
	Name:          "litereg",
	NetMagicBytes: 0xdab5bffa,
	DefaultPort:   "19444",
	DNSSeeds:      []string{},

	GenesisBlock: &liteCoinRegTestGenesisBlock,
	GenesisHash:  &liteCoinRegTestGenesisHash,
	PoWFunction: func(b []byte, height int32) chainhash.Hash {
		scryptBytes, _ := scrypt.Key(b, b, 1024, 1, 1, 32)
		asChainHash, _ := chainhash.NewHash(scryptBytes)
		return *asChainHash
	},
	DiffCalcFunction:         diffBitcoin,
	FeePerByte:               800,
	PowLimit:                 regressionPowLimit,
	PowLimitBits:             0x207fffff,
	CoinbaseMaturity:         100,
	SubsidyReductionInterval: 150,
	TargetTimespan:           time.Hour * 84,
	TargetTimePerBlock:       time.Second * 150,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      true,
	MinDiffReductionTime:     time.Minute * 10,
	GenerateSupported:        true,

	Checkpoints: []Checkpoint{},

	BlockEnforceNumRequired: 51,
	BlockRejectNumRequired:  75,
	BlockUpgradeNumToCheck:  100,

	RelayNonStdTxs: true,

	PubKeyHashAddrID: 0x6f,
	ScriptHashAddrID: 0xc4,
	Bech32Prefix:     "rltc",
	PrivateKeyID:     0xef,

	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},

	HDCoinType: 258,
}

LiteCoinTestNet4Params are the parameters for the litecoin test network 4.

View Source 
var (
	// RegisteredNets is the chains that Lit can support, by indexed cointype ID.
	RegisteredNets = make(map[uint32]*Params)
)
View Source 
var RegressionNetParams = Params{
	Name:          "regtest",
	NetMagicBytes: 0xdab5bffa,
	DefaultPort:   "18444",
	DNSSeeds:      []string{},

	GenesisBlock: &regTestGenesisBlock,
	GenesisHash:  &regTestGenesisHash,
	PoWFunction: func(b []byte, height int32) chainhash.Hash {
		return chainhash.DoubleHashH(b)
	},
	DiffCalcFunction: diffBitcoin,

	FeePerByte:               80,
	PowLimit:                 regressionPowLimit,
	PowLimitBits:             0x207fffff,
	CoinbaseMaturity:         100,
	SubsidyReductionInterval: 150,
	TargetTimespan:           time.Hour * 24 * 14,
	TargetTimePerBlock:       time.Minute * 10,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      true,
	MinDiffReductionTime:     time.Minute * 20,
	GenerateSupported:        true,

	Checkpoints: nil,

	BlockEnforceNumRequired: 750,
	BlockRejectNumRequired:  950,
	BlockUpgradeNumToCheck:  1000,

	RelayNonStdTxs: true,

	PubKeyHashAddrID: 0x6f,
	ScriptHashAddrID: 0xc4,
	PrivateKeyID:     0xef,
	Bech32Prefix:     "bcrt",

	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},

	HDCoinType: 257,
}

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 TestNet3Params = Params{
	Name:          "testnet3",
	NetMagicBytes: 0x0709110b,
	DefaultPort:   "18333",
	DNSSeeds: []string{
		"testnet-seed.bitcoin.jonasschnelli.ch",
		"seed.tbtc.petertodd.org",
		"seed.testnet.bitcoin.sprovoost.nl",
		"testnet-seed.bluematt.me",
	},

	GenesisBlock: &testNet3GenesisBlock,
	GenesisHash:  &testNet3GenesisHash,
	PoWFunction: func(b []byte, height int32) chainhash.Hash {
		return chainhash.DoubleHashH(b)
	},
	DiffCalcFunction: diffBitcoin,
	StartHeader: newHeaderFromStr("00000020b39e2c241c3fff2c7bf20bc5c5477dc7cedb" +
		"2154ccede1944800000000000000b767d1cb09db9e355835b7e94a385a4f82accea85c" +
		"ac5e6b067096bbd5dcf055fba7415aa313081a91ffefce"),
	StartHeight:              1255968,
	FeePerByte:               80,
	PowLimit:                 testNet3PowLimit,
	PowLimitBits:             0x1d00ffff,
	CoinbaseMaturity:         100,
	SubsidyReductionInterval: 210000,
	TargetTimespan:           time.Hour * 24 * 14,
	TargetTimePerBlock:       time.Minute * 10,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      true,
	MinDiffReductionTime:     time.Minute * 20,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{
		{546, newHashFromStr("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},
	},

	BlockEnforceNumRequired: 51,
	BlockRejectNumRequired:  75,
	BlockUpgradeNumToCheck:  100,

	RelayNonStdTxs: true,

	PubKeyHashAddrID: 0x6f,
	ScriptHashAddrID: 0xc4,
	Bech32Prefix:     "tb",
	PrivateKeyID:     0xef,

	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},

	HDCoinType: 1,
	TestCoin:   true,
}

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".

View Source 
var VertcoinGenesisBlock = wire.MsgBlock{
	Header: wire.BlockHeader{
		Version:    1,
		PrevBlock:  chainhash.Hash{},
		MerkleRoot: VertcoinMerkleRoot,
		Timestamp:  time.Unix(1389311371, 0),
		Bits:       0x1e0ffff0,
		Nonce:      5749262,
	},
}
View Source 
var VertcoinGenesisHash = chainhash.Hash([chainhash.HashSize]byte{
	0xc4, 0xf0, 0x89, 0x04, 0x11, 0x22, 0x2d, 0x49, 0x2c, 0xa1,
	0xce, 0x0c, 0x99, 0x3a, 0x01, 0x90, 0xcb, 0xdc, 0xe2, 0x1e,
	0x4d, 0x84, 0xc2, 0xe5, 0xb1, 0x40, 0x9d, 0xf4, 0x15, 0xa9,
	0x96, 0x4d,
})

VertcoinNetGenesisHash

View Source 
var VertcoinMerkleRoot = chainhash.Hash([chainhash.HashSize]byte{
	0xe7, 0x23, 0x01, 0xfc, 0x49, 0x32, 0x3e, 0xe1, 0x51, 0xcf, 0x10, 0x48, 0x23, 0x0f,
	0x03, 0x2c, 0xa5, 0x89, 0x75, 0x3b, 0xa7, 0x08, 0x62, 0x22, 0xa5, 0xc0, 0x23, 0xe3,
	0xa0, 0x8c, 0xf3, 0x4a,
})
View Source 
var VertcoinParams = Params{
	Name:          "vtc",
	NetMagicBytes: 0xdab5bffa,
	DefaultPort:   "5889",
	DNSSeeds: []string{
		"fr1.vtconline.org",
		"uk1.vtconline.org",
		"useast1.vtconline.org",
		"vtc.alwayshashing.com",
		"crypto.office-on-the.net",
		"p2pool.kosmoplovci.org",
	},

	StartHeader: [80]byte{
		0x02, 0x00, 0x00, 0x00, 0x36, 0xdc, 0x16, 0xc7, 0x71, 0x63,
		0x1c, 0x52, 0xa4, 0x3d, 0xb7, 0xb0, 0xa9, 0x86, 0x95, 0x95,
		0xed, 0x7d, 0xc1, 0x68, 0xe7, 0x2e, 0xaf, 0x0f, 0x55, 0x08,
		0x02, 0x98, 0x9f, 0x5c, 0x7b, 0xe4, 0x37, 0xa6, 0x90, 0x76,
		0x66, 0xa7, 0xba, 0x55, 0x75, 0xd8, 0x8a, 0xc5, 0x14, 0x01,
		0x86, 0x11, 0x8e, 0x34, 0xe2, 0x4a, 0x04, 0x7b, 0x9d, 0x6e,
		0x96, 0x41, 0xbb, 0x29, 0xe2, 0x04, 0xcb, 0x49, 0x3c, 0x53,
		0x08, 0x58, 0x3f, 0xf4, 0x4d, 0x1b, 0x42, 0x22, 0x6e, 0x8a,
	},
	StartHeight:      598752,
	AssumeDiffBefore: 602784,
	DiffCalcFunction: diffVTC,
	MinHeaders:       4032,
	FeePerByte:       100,
	GenesisBlock:     &VertcoinGenesisBlock,
	GenesisHash:      &VertcoinGenesisHash,
	PowLimit:         liteCoinTestNet4PowLimit,
	PoWFunction: func(b []byte, height int32) chainhash.Hash {
		var hashBytes []byte

		if height >= 347000 {
			hashBytes, _ = lyra2rev2.Sum(b)
		} else if height >= 208301 {
			hashBytes, _ = lyra2re.Sum(b)
		} else {
			hashBytes, _ = scrypt.Key(b, b, 2048, 1, 1, 32)
		}

		asChainHash, _ := chainhash.NewHash(hashBytes)
		return *asChainHash
	},
	PowLimitBits:             0x1e0fffff,
	CoinbaseMaturity:         120,
	SubsidyReductionInterval: 840000,
	TargetTimespan:           time.Second * 302400,
	TargetTimePerBlock:       time.Second * 150,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      false,
	MinDiffReductionTime:     time.Second * 150 * 2,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{
		{0, newHashFromStr("4d96a915f49d40b1e5c2844d1ee2dccb90013a990ccea12c492d22110489f0c4")},
		{24200, newHashFromStr("d7ed819858011474c8b0cae4ad0b9bdbb745becc4c386bc22d1220cc5a4d1787")},
		{65000, newHashFromStr("9e673a69c35a423f736ab66f9a195d7c42f979847a729c0f3cef2c0b8b9d0289")},
		{84065, newHashFromStr("a904170a5a98109b2909379d9bc03ef97a6b44d5dafbc9084b8699b0cba5aa98")},
		{228023, newHashFromStr("15c94667a9e941359d2ee6527e2876db1b5e7510a5ded3885ca02e7e0f516b51")},
		{346992, newHashFromStr("f1714fa4c7990f4b3d472eb22132891ccd3c7ad7208e2d1ab15bde68854fb0ee")},
		{347269, newHashFromStr("fa1e592b7ea2aa97c5f20ccd7c40f3aaaeb31d1232c978847a79f28f83b6c22a")},
		{430000, newHashFromStr("2f5703cf7b6f956b84fd49948cbf49dc164cfcb5a7b55903b1c4f53bc7851611")},
		{516999, newHashFromStr("572ed47da461743bcae526542053e7bc532de299345e4f51d77786f2870b7b28")},
		{627610, newHashFromStr("6000a787f2d8bb77d4f491a423241a4cc8439d862ca6cec6851aba4c79ccfedc")},
	},

	BlockEnforceNumRequired: 1512,
	BlockRejectNumRequired:  1915,
	BlockUpgradeNumToCheck:  2016,

	RelayNonStdTxs: true,

	PubKeyHashAddrID: 0x47,
	ScriptHashAddrID: 0x05,
	Bech32Prefix:     "vtc",
	PrivateKeyID:     0x80,

	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},

	HDCoinType: 28,
}
View Source 
var VertcoinTestNetParams = Params{
	Name:          "vtctest",
	NetMagicBytes: 0x74726576,
	DefaultPort:   "15889",
	DNSSeeds: []string{
		"fr1.vtconline.org",
	},

	DiffCalcFunction: diffVTCtest,
	MinHeaders:       4032,
	FeePerByte:       100,
	GenesisBlock:     &VertcoinTestnetGenesisBlock,
	GenesisHash:      &VertcoinTestnetGenesisHash,
	PowLimit:         liteCoinTestNet4PowLimit,
	PoWFunction: func(b []byte, height int32) chainhash.Hash {
		lyraBytes, _ := lyra2rev2.Sum(b)
		asChainHash, _ := chainhash.NewHash(lyraBytes)
		return *asChainHash
	},
	PowLimitBits:             0x1e0fffff,
	CoinbaseMaturity:         120,
	SubsidyReductionInterval: 840000,
	TargetTimespan:           time.Second * 302400,
	TargetTimePerBlock:       time.Second * 150,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      true,
	MinDiffReductionTime:     time.Second * 150 * 2,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{},

	BlockEnforceNumRequired: 26,
	BlockRejectNumRequired:  49,
	BlockUpgradeNumToCheck:  50,

	RelayNonStdTxs: true,

	PubKeyHashAddrID: 0x4a,
	ScriptHashAddrID: 0xc4,
	Bech32Prefix:     "tvtc",
	PrivateKeyID:     0xef,

	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94},
	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf},

	HDCoinType: 65536,
}
View Source 
var VertcoinTestnetGenesisBlock = wire.MsgBlock{
	Header: wire.BlockHeader{
		Version:    1,
		PrevBlock:  chainhash.Hash{},
		MerkleRoot: VertcoinTestnetMerkleRoot,
		Timestamp:  time.Unix(1481291250, 0),
		Bits:       0x1e0ffff0,
		Nonce:      915027,
	},
}
View Source 
var VertcoinTestnetGenesisHash = chainhash.Hash([chainhash.HashSize]byte{
	0xc9, 0xd2, 0x7a, 0x49, 0x47, 0x27, 0x2e, 0xe3, 0xc2,
	0xe8, 0x1a, 0x74, 0xb6, 0x79, 0xac, 0xec, 0x5d, 0x85,
	0xa4, 0x6a, 0x97, 0x16, 0x79, 0xf0, 0xc8, 0x64, 0x7a,
	0xeb, 0x4f, 0xf2, 0xe8, 0xce,
})

VertcoinTestNetGenesisHash

View Source 
var VertcoinTestnetMerkleRoot = chainhash.Hash([chainhash.HashSize]byte{
	0xe7, 0x23, 0x01, 0xfc, 0x49, 0x32, 0x3e, 0xe1, 0x51,
	0xcf, 0x10, 0x48, 0x23, 0x0f, 0x03, 0x2c, 0xa5, 0x89,
	0x75, 0x3b, 0xa7, 0x08, 0x62, 0x22, 0xa5, 0xc0, 0x23,
	0xe3, 0xa0, 0x8c, 0xf3, 0x4a,
})
View Source 
var ViacoinGenesisBlock = wire.MsgBlock{
	Header: wire.BlockHeader{
		Version:    1,
		PrevBlock:  chainhash.Hash{},
		MerkleRoot: ViacoinMerkleRoot,
		Timestamp:  time.Unix(1405164774, 0),
		Bits:       0x1e01ffff,
		Nonce:      4016033,
	},
}
View Source 
var ViacoinGenesisHash = chainhash.Hash([chainhash.HashSize]byte{
	0xa1, 0x0b, 0x40, 0x9a, 0x53, 0xa1, 0x1d, 0x97,
	0x79, 0x0d, 0x97, 0x70, 0x5a, 0xe3, 0xab, 0xea,
	0x15, 0x15, 0x33, 0xc0, 0x8e, 0x12, 0x30, 0x98,
	0x04, 0x76, 0x99, 0x1f, 0x00, 0x54, 0x0b, 0x4e,
})
View Source 
var ViacoinMerkleRoot = chainhash.Hash([chainhash.HashSize]byte{
	0x00, 0x52, 0x27, 0x53, 0x00, 0x29, 0x39, 0xc7,
	0x86, 0x59, 0xb4, 0xfd, 0xc6, 0xed, 0x56, 0xc6,
	0xb6, 0xaa, 0xcd, 0xc7, 0x58, 0x6f, 0xac, 0xf2,
	0xf6, 0xad, 0xa2, 0x01, 0x2e, 0xd3, 0x17, 0x03,
})
View Source 
var ViacoinParams = Params{
	Name:          "via",
	NetMagicBytes: 0xcbc6680f,
	DefaultPort:   "5223",
	DNSSeeds: []string{
		"seed.viacoin.net",
		"viaseeder.barbatos.fr",
		"mainnet.viacoin.net",
	},

	StartHeader:      [80]byte{},
	StartHeight:      0x02,
	AssumeDiffBefore: 0,
	DiffCalcFunction: diffBitcoin,
	MinHeaders:       4032,
	FeePerByte:       100,
	GenesisBlock:     &ViacoinGenesisBlock,
	GenesisHash:      &ViacoinGenesisHash,
	PowLimit:         liteCoinTestNet4PowLimit,

	PowLimitBits:             0x1e01ffff,
	CoinbaseMaturity:         100,
	SubsidyReductionInterval: 657000,
	TargetTimespan:           time.Hour * 24 * 14,
	TargetTimePerBlock:       time.Second * 24,
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      false,
	MinDiffReductionTime:     0,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{
		{3901, newHashFromStr("39c94020b653871bbcb29c9489bb12f84c5e89adef75f2e5c5f59e88869129d9")},
		{40821, newHashFromStr("e0471675f9c98aa5ed321ed951d140d4603d96254a4ca9fbca07b8da5ee11954")},
		{41433, newHashFromStr("627e18cc08a276282781705bac09508992dc8b665391edd7bde8a601f011954c")},
		{44606, newHashFromStr("5ceeec38564a36ee3e1e5404970f5715efe0420e92c8e92bedfdfef782c49320")},
		{200000, newHashFromStr("ccd02ffc90ee744cc90fa95aafb75e793e306dac533abf6162c4c5be3c7b80ad")},
		{400000, newHashFromStr("7884c4cc5564a2414d6b9eaebd6cb2e4df47bcce7eb7f5c24b19f2d3bf961fd3")},
		{600000, newHashFromStr("2385e13879304c4223b479267b3a8aca709b3556d0a00b431efc5b4174080d91")},
		{800000, newHashFromStr("964a15c07915e3f1935e28d66f869fba7d63862ce1b494b3ebbb38bb16092f93")},
		{1000000, newHashFromStr("1b187fb9e32e2ce80fc7a151254ef331b225a22dd2f2407d8e90b6276b252047")},
		{1200000, newHashFromStr("db284e629a1ceb3cbf563293e23adecbe57bc0f3a6999b53598c5cdd5f6a74db")},
		{1400000, newHashFromStr("a45e9c776a911978e22cc9c9d01f92c30836bffb6162cffdf96df75e21e1e97e")},
		{1600000, newHashFromStr("26976af79d69b40c23d22a10c9b0440e7ab450dc390128996abdde5704caef81")},
		{1800000, newHashFromStr("a6d494764b8dc454d1d5178fb4adef06784cc5713c91709f90d42d7515bcf2f6")},
		{2000000, newHashFromStr("f363858fb9ef0ecb0c0ac1c690856129863ce65563581adef000c95733ca7fd9")},
		{2200000, newHashFromStr("edb79185486f009823e3eb5a9e8ba877fd923ce278d2b235586cbde47534b1aa")},
		{2400000, newHashFromStr("34f603a7dee67c2c298d607bb40b79a9641b0618671bcacf6c33c77a8f39b0ac")},
		{2600000, newHashFromStr("162c711903353c479d2c4db85eaaa8e02335b337b3065076edf6315e54ecad90")},
		{2800000, newHashFromStr("ab66f0ead8af2420ff28d23836fc3e6aaefb5b04d56ea8ea1e37dc289eb5f5ce")},
		{3000000, newHashFromStr("6382616446e421105760a83ac69ddffd2b13678b3f12895fea2a4a830cbd5e11")},
		{3200000, newHashFromStr("754d508c62c4a8d8c0abc7249f801b454aa016d628af0b18838ca31ea8c24799")},
		{3470255, newHashFromStr("c3f75474ed8171bc303b4cd7ff269592534c0ca8d76fceed3fdbf8abf40d147a")},
		{3600000, newHashFromStr("8bc0e14a2fc7eea4fd560fbdaa5e4162d352cc61766a2bb1b49218766646317e")},
		{3800000, newHashFromStr("36a845e155c750762f16e5a95c91dbfce58e0dcf9ee2b5e5e4ffe38a0d609111")},
		{4000000, newHashFromStr("9b1fa0fa4183c12480ff04aeaadc03051b9fe94d07d444fc454d58ed0b846534")},
		{4200000, newHashFromStr("4ad4e7a68d2510fc28ede94a13bdd73cf321135b85168298b5c67bd63c700d92")},
		{4400000, newHashFromStr("8a46b52e986f04b07e732caefdfb4c9083a9b88240cd7b3c0e48556c07b62f1a")},
		{4600000, newHashFromStr("6ae5f0132613bc0a61167ff78ba3309f0f56e06960099b1a4c99658671abd8c2")},
	},

	BlockEnforceNumRequired: 51,
	BlockRejectNumRequired:  75,
	BlockUpgradeNumToCheck:  100,

	RelayNonStdTxs: true,

	PubKeyHashAddrID: 0x47,
	ScriptHashAddrID: 0x21,
	Bech32Prefix:     "via",
	PrivateKeyID:     0xc7,

	HDCoinType: 14,
}

Functions

func BigToCompact 

func BigToCompact(n *big.Int) uint32

BigToCompact converts a whole number N to a compact representation using an unsigned 32-bit number. The compact representation only provides 23 bits of precision, so values larger than (2^23 - 1) only encode the most significant digits of the number. See CompactToBig for details.

func CompactToBig 

func CompactToBig(compact uint32) *big.Int

CompactToBig converts a compact representation of a whole number N to an unsigned 32-bit number. The representation is similar to IEEE754 floating point numbers.

Like IEEE754 floating point, there are three basic components: the sign, the exponent, and the mantissa. They are broken out as follows:

  • the most significant 8 bits represent the unsigned base 256 exponent

  • bit 23 (the 24th bit) represents the sign bit

  • the least significant 23 bits represent the mantissa

    ------------------------------------------------- | Exponent | Sign | Mantissa | ------------------------------------------------- | 8 bits [31-24] | 1 bit [23] | 23 bits [22-00] | -------------------------------------------------

The formula to calculate N is: 

N = (-1^sign) * mantissa * 256^(exponent-3)

This compact form is only used in bitcoin to encode unsigned 256-bit numbers which represent difficulty targets, thus there really is not a need for a sign bit, but it is implemented here to stay consistent with bitcoind.

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 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 PrefixToCoinType 

func PrefixToCoinType(prefix string) (uint32, error)

PrefixToCoinType returns the HDCoinType for a params set given the bech32 prefix. If that prefix isn't registered, it returns an error.

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
}

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 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.
	NetMagicBytes uint32

	// 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 []string

	// GenesisBlock defines the first block of the chain.
	GenesisBlock *wire.MsgBlock

	// GenesisHash is the starting block hash.
	GenesisHash *chainhash.Hash

	// The function used to calculate the proof of work value for a block
	PoWFunction func(b []byte, height int32) chainhash.Hash

	// The function used to calculate the difficulty of a given block
	DiffCalcFunction func(
		headers []*wire.BlockHeader, height int32, p *Params) (uint32, error)

	// The block header to start downloading blocks from
	StartHeader [80]byte

	// The height of the StartHash
	StartHeight int32

	// Assume the difficulty bits are valid before this header height
	// This is needed for coins with variable retarget lookbacks that use
	// StartHeader to offset the beginning of the header chain for SPV
	AssumeDiffBefore int32

	// The minimum number of headers to pass to the difficulty function.
	// This is primarily intended for coins that have difficulty functions
	// without fixed epoch lengths
	MinHeaders int32

	// Fee per byte for transactions
	FeePerByte int64

	// 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

	// 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

	// 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

	// GenerateSupported specifies whether or not CPU mining is allowed.
	GenerateSupported bool

	// Checkpoints ordered from oldest to newest.
	Checkpoints []Checkpoint

	// Enforce current block version once network has
	// upgraded.  This is part of BIP0034.
	BlockEnforceNumRequired uint64

	// Reject previous block versions once network has
	// upgraded.  This is part of BIP0034.
	BlockRejectNumRequired uint64

	// The number of nodes to check.  This is part of BIP0034.
	BlockUpgradeNumToCheck uint64

	// Mempool parameters
	RelayNonStdTxs bool

	// Address encoding magics
	PubKeyHashAddrID byte   // First byte of a P2PKH address
	ScriptHashAddrID byte   // First byte of a P2SH address
	PrivateKeyID     byte   // First byte of a WIF private key
	Bech32Prefix     string // HRP for bech32 address

	// 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

	// TestCoin, when true, indicates that the network deals with money that
	// isn't worth anything.  This can be useful to skip over security code,
	//
	TestCoin bool
}

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.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.