chaincfg

package
v0.25.0 Latest Latest
Warning

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

 Go to latest Published: Sep 3, 2024 License: ISC Imports: 9 Imported by: 9

README

chaincfg

Build Status ISC License GoDoc

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

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

Sample Use

package main

import (
	"flag"
	"fmt"
	"log"

	"github.com/ltcmweb/ltcd/ltcutil"
	"github.com/ltcmweb/ltcd/chaincfg"
)

var testnet = flag.Bool("testnet", false, "operate on the testnet Litecoin 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.TestNet4Params
	}

	// later...

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

Installation and Updating

$ go get -u github.com/ltcmweb/ltcd/chaincfg

GPG Verification Key

All official release tags are signed by Conformal so users can ensure the code has not been tampered with and is coming from the ltcsuite developers. To verify the signature perform the following:

  • Download the public key from the Conformal website at https://opensource.conformal.com/GIT-GPG-KEY-conformal.txt

  • Import the public key into your GPG keyring:

    gpg --import GIT-GPG-KEY-conformal.txt

  • Verify the release tag with the following command where TAG_NAME is a placeholder for the specific tag:

    git tag -v TAG_NAME

License

Package chaincfg is licensed under the copyfree ISC License.

Documentation

Overview

Package chaincfg defines chain configuration parameters.

In addition to the main Litecoin 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/ltcmweb/ltcd/ltcutil"
        "github.com/ltcmweb/ltcd/chaincfg"
)

var testnet = flag.Bool("testnet", false, "operate on the testnet Litecoin 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.TestNet4Params
        }

        // later...

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

If an application does not use one of the three standard Litecoin 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 testnet sharing magics).

Index

Constants

View Source 
const (
	// DeploymentTestDummy defines the rule change deployment ID for testing
	// purposes.
	DeploymentTestDummy = iota

	// DeploymentTestDummyMinActivation defines the rule change deployment
	// ID for testing purposes. This differs from the DeploymentTestDummy
	// in that it specifies the newer params the taproot fork used for
	// activation: a custom threshold and a min activation height.
	DeploymentTestDummyMinActivation

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

	// DeploymentSegwit defines the rule change deployment ID for the
	// Segregated Witness (segwit) soft-fork package. The segwit package
	// includes the deployment of BIPS 141, 142, 144, 145, 147 and 173.
	DeploymentSegwit

	// DeploymentTaproot defines the rule change deployment ID for the
	// Taproot (+Schnorr) soft-fork package. The taproot package includes
	// the deployment of BIPS 340, 341 and 342.
	DeploymentTaproot

	// DeploymentMweb defines the rule change deployment ID for the
	// MWEB soft-fork package. The MWEB package includes the deployment
	// of LIPS 2, 3 and 4.
	DeploymentMweb

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

	// DefaultSignetChallenge is the byte representation of the signet
	// challenge for the default (public, Taproot enabled) signet network.
	// This is the binary equivalent of the litecoin script
	//  1 03ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430
	//  0359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c4 2
	//  OP_CHECKMULTISIG
	DefaultSignetChallenge, _ = hex.DecodeString(
		"512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d" +
			"1e086be430210359ef5021964fe22d6f8e05b2463c9540ce9688" +
			"3fe3b278760f048f5189f2e6c452ae",
	)

	// DefaultSignetDNSSeeds is the list of seed nodes for the default
	// (public, Taproot enabled) signet network.
	DefaultSignetDNSSeeds = []DNSSeed{
		{"178.128.221.177", false},
		{"2a01:7c8:d005:390::5", false},
		{"v7ajjeirttkbnt32wpy3c6w3emwnfr3fkla7hpxcfokr3ysd3kqtzmqd.onion:38333", false},
	}
)

These variables are the chain proof-of-work limit parameters for each default network.

View Source 
var (
	// ErrDuplicateNet describes an error where the parameters for a Litecoin
	// network could not be set due to the network already being a standard
	// network or previously-registered into this package.
	ErrDuplicateNet = errors.New("duplicate Litecoin 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")

	// ErrInvalidHDKeyID describes an error where the provided hierarchical
	// deterministic version bytes, or hd key id, is malformed.
	ErrInvalidHDKeyID = errors.New("invalid hd extended key version bytes")
)
View Source 
var (
	// ErrNoBlockClock is returned when an operation fails due to lack of
	// synchornization with the current up to date block clock.
	ErrNoBlockClock = fmt.Errorf("no block clock synchronized")
)
View Source 
var MainNetParams = Params{
	Name:        "mainnet",
	Net:         wire.MainNet,
	DefaultPort: "9333",
	DNSSeeds: []DNSSeed{
		{"seed-a.litecoin.loshan.co.uk", true},
		{"dnsseed.thrasher.io", true},
		{"dnsseed.litecointools.com", false},
		{"dnsseed.litecoinpool.org", false},
	},

	GenesisBlock:             &genesisBlock,
	GenesisHash:              &genesisHash,
	PowLimit:                 mainPowLimit,
	PowLimitBits:             0x1e0ffff0,
	BIP0034Height:            710000,
	BIP0065Height:            918684,
	BIP0066Height:            811879,
	CoinbaseMaturity:         100,
	MwebPegoutMaturity:       6,
	SubsidyReductionInterval: 840000,
	TargetTimespan:           (time.Hour * 24 * 3) + (time.Hour * 12),
	TargetTimePerBlock:       (time.Minute * 2) + (time.Second * 30),
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      false,
	MinDiffReductionTime:     0,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{
		{1500, newHashFromStr("841a2965955dd288cfa707a755d05a54e45f8bd476835ec9af4402a2b59a2967")},
		{4032, newHashFromStr("9ce90e427198fc0ef05e5905ce3503725b80e26afd35a987965fd7e3d9cf0846")},
		{8064, newHashFromStr("eb984353fc5190f210651f150c40b8a4bab9eeeff0b729fcb3987da694430d70")},
		{16128, newHashFromStr("602edf1859b7f9a6af809f1d9b0e6cb66fdc1d4d9dcd7a4bec03e12a1ccd153d")},
		{23420, newHashFromStr("d80fdf9ca81afd0bd2b2a90ac3a9fe547da58f2530ec874e978fce0b5101b507")},
		{50000, newHashFromStr("69dc37eb029b68f075a5012dcc0419c127672adb4f3a32882b2b3e71d07a20a6")},
		{80000, newHashFromStr("4fcb7c02f676a300503f49c764a89955a8f920b46a8cbecb4867182ecdb2e90a")},
		{120000, newHashFromStr("bd9d26924f05f6daa7f0155f32828ec89e8e29cee9e7121b026a7a3552ac6131")},
		{161500, newHashFromStr("dbe89880474f4bb4f75c227c77ba1cdc024991123b28b8418dbbf7798471ff43")},
		{179620, newHashFromStr("2ad9c65c990ac00426d18e446e0fd7be2ffa69e9a7dcb28358a50b2b78b9f709")},
		{240000, newHashFromStr("7140d1c4b4c2157ca217ee7636f24c9c73db39c4590c4e6eab2e3ea1555088aa")},
		{383640, newHashFromStr("2b6809f094a9215bafc65eb3f110a35127a34be94b7d0590a096c3f126c6f364")},
		{409004, newHashFromStr("487518d663d9f1fa08611d9395ad74d982b667fbdc0e77e9cf39b4f1355908a3")},
		{456000, newHashFromStr("bf34f71cc6366cd487930d06be22f897e34ca6a40501ac7d401be32456372004")},
		{638902, newHashFromStr("15238656e8ec63d28de29a8c75fcf3a5819afc953dcd9cc45cecc53baec74f38")},
		{721000, newHashFromStr("198a7b4de1df9478e2463bd99d75b714eab235a2e63e741641dc8a759a9840e5")},
	},

	RuleChangeActivationThreshold: 6048,
	MinerConfirmationWindow:       8064,
	Deployments: [DefinedDeployments]ConsensusDeployment{
		DeploymentTestDummy: {
			BitNumber: 28,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Unix(11991456010, 0),
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Unix(1230767999, 0),
			),
		},
		DeploymentTestDummyMinActivation: {
			BitNumber:                 22,
			CustomActivationThreshold: 1815,
			MinActivationHeight:       10_0000,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},

		DeploymentCSV: {
			BitNumber: 0,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Unix(1462060800, 0),
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Unix(1493596800, 0),
			),
		},
		DeploymentSegwit: {
			BitNumber: 1,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Unix(1479168000, 0),
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Unix(1510704000, 0),
			),
		},
		DeploymentTaproot: {
			BitNumber: 2,
			DeploymentStarter: NewBlockHeightDeploymentStarter(
				2161152,
			),
			DeploymentEnder: NewBlockHeightDeploymentEnder(
				2370816,
			),
		},
		DeploymentMweb: {
			BitNumber: 4,
			DeploymentStarter: NewBlockHeightDeploymentStarter(
				2217600,
			),
			DeploymentEnder: NewBlockHeightDeploymentEnder(
				2427264,
			),
		},
	},

	RelayNonStdTxs: false,

	Bech32HRPSegwit: "ltc",

	Bech32HRPMweb: "ltcmweb",

	PubKeyHashAddrID:        0x30,
	ScriptHashAddrID:        0x32,
	PrivateKeyID:            0xB0,
	WitnessPubKeyHashAddrID: 0x06,
	WitnessScriptHashAddrID: 0x0A,

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

	HDCoinType: 2,
}

MainNetParams defines the network parameters for the main Litecoin network.

View Source 
var RegressionNetParams = Params{
	Name:        "regtest",
	Net:         wire.TestNet,
	DefaultPort: "18444",
	DNSSeeds:    []DNSSeed{},

	GenesisBlock:             &regTestGenesisBlock,
	GenesisHash:              &regTestGenesisHash,
	PowLimit:                 regressionPowLimit,
	PowLimitBits:             0x207fffff,
	PoWNoRetargeting:         true,
	CoinbaseMaturity:         100,
	MwebPegoutMaturity:       6,
	BIP0034Height:            100000000,
	BIP0065Height:            1351,
	BIP0066Height:            1251,
	SubsidyReductionInterval: 150,
	TargetTimespan:           (time.Hour * 24 * 3) + (time.Hour * 12),
	TargetTimePerBlock:       (time.Minute * 2) + (time.Second * 30),
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      true,
	MinDiffReductionTime:     time.Minute * 20,
	GenerateSupported:        true,

	Checkpoints: nil,

	RuleChangeActivationThreshold: 108,
	MinerConfirmationWindow:       144,
	Deployments: [DefinedDeployments]ConsensusDeployment{
		DeploymentTestDummy: {
			BitNumber: 28,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentTestDummyMinActivation: {
			BitNumber:                 22,
			CustomActivationThreshold: 72,
			MinActivationHeight:       600,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentCSV: {
			BitNumber: 0,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentSegwit: {
			BitNumber: 1,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentTaproot: {
			BitNumber: 2,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentMweb: {
			BitNumber: 4,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Unix(1601450001, 0),
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
	},

	RelayNonStdTxs: true,

	Bech32HRPSegwit: "rltc",

	Bech32HRPMweb: "tmweb",

	PubKeyHashAddrID: 0x6f,
	ScriptHashAddrID: 0x3a,
	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 Litecoin network. Not to be confused with the test Litecoin network (version 4), this network is sometimes simply called "testnet".

View Source 
var SigNetParams = CustomSignetParams(
	DefaultSignetChallenge, DefaultSignetDNSSeeds,
)

SigNetParams defines the network parameters for the default public signet Litecoin network. Not to be confused with the regression test network, this network is sometimes simply called "signet" or "taproot signet".

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,
	CoinbaseMaturity:         100,
	MwebPegoutMaturity:       6,
	SubsidyReductionInterval: 210000,
	TargetTimespan:           (time.Hour * 24 * 3) + (time.Hour * 12),
	TargetTimePerBlock:       (time.Minute * 2) + (time.Second * 30),
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      true,
	MinDiffReductionTime:     time.Minute * 20,
	GenerateSupported:        true,

	Checkpoints: nil,

	RuleChangeActivationThreshold: 75,
	MinerConfirmationWindow:       100,
	Deployments: [DefinedDeployments]ConsensusDeployment{
		DeploymentTestDummy: {
			BitNumber: 28,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentTestDummyMinActivation: {
			BitNumber:                 22,
			CustomActivationThreshold: 50,
			MinActivationHeight:       600,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentCSV: {
			BitNumber: 0,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentSegwit: {
			BitNumber: 1,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentTaproot: {
			BitNumber: 2,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
			CustomActivationThreshold: 75,
		},
	},

	RelayNonStdTxs: true,

	Bech32HRPSegwit: "sltc",

	PubKeyHashAddrID:        0x3f,
	ScriptHashAddrID:        0x7b,
	PrivateKeyID:            0x64,
	WitnessPubKeyHashAddrID: 0x19,
	WitnessScriptHashAddrID: 0x28,

	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 Litecoin 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 TestNet4Params = Params{
	Name:        "testnet4",
	Net:         wire.TestNet4,
	DefaultPort: "19335",
	DNSSeeds: []DNSSeed{
		{"testnet-seed.litecointools.com", false},
		{"seed-b.litecoin.loshan.co.uk", true},
		{"dnsseed-testnet.thrasher.io", true},
	},

	GenesisBlock:             &testNet4GenesisBlock,
	GenesisHash:              &testNet4GenesisHash,
	PowLimit:                 testNet4PowLimit,
	PowLimitBits:             0x1e0fffff,
	BIP0034Height:            76,
	BIP0065Height:            76,
	BIP0066Height:            76,
	CoinbaseMaturity:         100,
	MwebPegoutMaturity:       6,
	SubsidyReductionInterval: 840000,
	TargetTimespan:           (time.Hour * 24 * 3) + (time.Hour * 12),
	TargetTimePerBlock:       (time.Minute * 2) + (time.Second * 30),
	RetargetAdjustmentFactor: 4,
	ReduceMinDifficulty:      true,
	MinDiffReductionTime:     time.Minute * 5,
	GenerateSupported:        false,

	Checkpoints: []Checkpoint{
		{26115, newHashFromStr("817d5b509e91ab5e439652eee2f59271bbc7ba85021d720cdb6da6565b43c14f")},
		{43928, newHashFromStr("7d86614c153f5ef6ad878483118ae523e248cd0dd0345330cb148e812493cbb4")},
		{69296, newHashFromStr("66c2f58da3cfd282093b55eb09c1f5287d7a18801a8ff441830e67e8771010df")},
		{99949, newHashFromStr("8dd471cb5aecf5ead91e7e4b1e932c79a0763060f8d93671b6801d115bfc6cde")},
		{159256, newHashFromStr("ab5b0b9968842f5414804591119d6db829af606864b1959a25d6f5c114afb2b7")},
		{2394367, newHashFromStr("bc5829f4973d0797755efee11313687b3c63ee2f70b60b62eebcd10283534327")},
	},

	RuleChangeActivationThreshold: 1512,
	MinerConfirmationWindow:       2016,
	Deployments: [DefinedDeployments]ConsensusDeployment{
		DeploymentTestDummy: {
			BitNumber: 28,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Unix(1199145601, 0),
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Unix(1230767999, 0),
			),
		},
		DeploymentTestDummyMinActivation: {
			BitNumber:                 22,
			CustomActivationThreshold: 1815,
			MinActivationHeight:       10_0000,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Time{},
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Time{},
			),
		},
		DeploymentCSV: {
			BitNumber: 0,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Unix(1456790400, 0),
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Unix(1493596800, 0),
			),
		},
		DeploymentSegwit: {
			BitNumber: 1,
			DeploymentStarter: NewMedianTimeDeploymentStarter(
				time.Unix(1462060800, 0),
			),
			DeploymentEnder: NewMedianTimeDeploymentEnder(
				time.Unix(1493596800, 0),
			),
		},
		DeploymentTaproot: {
			BitNumber: 2,
			DeploymentStarter: NewBlockHeightDeploymentStarter(
				2225664,
			),
			DeploymentEnder: NewBlockHeightDeploymentEnder(
				2435328,
			),
		},
		DeploymentMweb: {
			BitNumber: 4,
			DeploymentStarter: NewBlockHeightDeploymentStarter(
				2209536,
			),
			DeploymentEnder: NewBlockHeightDeploymentEnder(
				2419200,
			),
		},
	},

	RelayNonStdTxs: true,

	Bech32HRPSegwit: "tltc",

	Bech32HRPMweb: "tmweb",

	PubKeyHashAddrID:        0x6f,
	ScriptHashAddrID:        0x3a,
	WitnessPubKeyHashAddrID: 0x52,
	WitnessScriptHashAddrID: 0x31,
	PrivateKeyID:            0xef,

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

	HDCoinType: 1,
}

TestNet4Params defines the network parameters for the test Litecoin network (version 4). 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 IsBech32MwebPrefix 

func IsBech32MwebPrefix(prefix string) bool

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

func IsBech32SegwitPrefix 

func IsBech32SegwitPrefix(prefix string) bool

IsBech32SegwitPrefix returns whether the prefix is a known prefix for segwit addresses 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 Litecoin 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.

func RegisterHDKeyID 

func RegisterHDKeyID(hdPublicKeyID []byte, hdPrivateKeyID []byte) error

RegisterHDKeyID registers a public and private hierarchical deterministic extended key ID pair.

Non-standard HD version bytes, such as the ones documented in SLIP-0132, should be registered using this method for library packages to lookup key IDs (aka HD version bytes). When the provided key IDs are invalid, the ErrInvalidHDKeyID error will be returned.

Reference: 

SLIP-0132 : Registered HD version bytes for BIP-0032
https://github.com/satoshilabs/slips/blob/master/slip-0132.md

Types

type BlockClock 

type BlockClock interface {
	// PastMedianTime returns the past median time from the PoV of the
	// passed block header. The past median time is the median time of the
	// 11 blocks prior to the passed block header.
	PastMedianTime(*wire.BlockHeader) (time.Time, error)
}

BlockClock is an abstraction over the past median time computation. The past median time computation is used in several consensus checks such as CSV, and also BIP 9 version bits. This interface allows callers to abstract away the computation of the past median time from the perspective of a given block header.

type BlockHeightDeploymentEnder 

type BlockHeightDeploymentEnder struct {
	// contains filtered or unexported fields
}

BlockHeightDeploymentEnder is a ConsensusDeploymentEnder that uses block height to determine if a deployment has ended.

func NewBlockHeightDeploymentEnder 

func NewBlockHeightDeploymentEnder(endHeight int32) *BlockHeightDeploymentEnder

NewBlockHeightDeploymentEnder returns a new instance of the BlockHeightDeploymentEnder for a given block height.

func (*BlockHeightDeploymentEnder) EndHeight 

func (b *BlockHeightDeploymentEnder) EndHeight() int32

EndHeight returns the raw end block height of the deployment.

func (*BlockHeightDeploymentEnder) HasEnded 

func (b *BlockHeightDeploymentEnder) HasEnded(
	blkHeader *wire.BlockHeader, blkHeight int32) (bool, error)

HasEnded returns true if the deployment has ended.

type BlockHeightDeploymentStarter 

type BlockHeightDeploymentStarter struct {
	// contains filtered or unexported fields
}

BlockHeightDeploymentStarter is a ConsensusDeploymentStarter that uses block height to determine if a deployment has started.

func NewBlockHeightDeploymentStarter 

func NewBlockHeightDeploymentStarter(startHeight int32) *BlockHeightDeploymentStarter

NewBlockHeightDeploymentStarter returns a new instance of a BlockHeightDeploymentStarter for a given block height.

func (*BlockHeightDeploymentStarter) HasStarted 

func (b *BlockHeightDeploymentStarter) HasStarted(
	blkHeader *wire.BlockHeader, blkHeight int32) (bool, error)

HasStarted returns true if the consensus deployment has started.

func (*BlockHeightDeploymentStarter) StartHeight 

func (b *BlockHeightDeploymentStarter) StartHeight() int32

StartHeight returns the raw start block height of the deployment.

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 ClockConsensusDeploymentEnder 

type ClockConsensusDeploymentEnder interface {
	ConsensusDeploymentEnder

	// SynchronizeClock synchronizes the target ConsensusDeploymentStarter
	// with the current up-to date BlockClock.
	SynchronizeClock(clock BlockClock)
}

ClockConsensusDeploymentEnder is a more specialized version of the ConsensusDeploymentEnder that uses a BlockClock in order to determine if a deployment has started or not.

NOTE: Any calls to HasEnded will _fail_ with ErrNoBlockClock if they happen before SynchronizeClock is executed.

type ClockConsensusDeploymentStarter 

type ClockConsensusDeploymentStarter interface {
	ConsensusDeploymentStarter

	// SynchronizeClock synchronizes the target ConsensusDeploymentStarter
	// with the current up-to date BlockClock.
	SynchronizeClock(clock BlockClock)
}

ClockConsensusDeploymentStarter is a more specialized version of the ConsensusDeploymentStarter that uses a BlockClock in order to determine if a deployment has started or not.

NOTE: Any calls to HasStarted will _fail_ with ErrNoBlockClock if they happen before SynchronizeClock is executed.

type ConsensusDeployment 

type ConsensusDeployment struct {
	// BitNumber defines the specific bit number within the block version
	// this particular soft-fork deployment refers to.
	BitNumber uint8

	// MinActivationHeight is an optional field that when set (default
	// value being zero), modifies the traditional BIP 9 state machine by
	// only transitioning from LockedIn to Active once the block height is
	// greater than (or equal to) thus specified height.
	MinActivationHeight uint32

	// CustomActivationThreshold if set (non-zero), will _override_ the
	// existing RuleChangeActivationThreshold value set at the
	// network/chain level. This value divided by the active
	// MinerConfirmationWindow denotes the threshold required for
	// activation. A value of 1815 block denotes a 90% threshold.
	CustomActivationThreshold uint32

	// DeploymentStarter is used to determine if the given
	// ConsensusDeployment has started or not.
	DeploymentStarter ConsensusDeploymentStarter

	// DeploymentEnder is used to determine if the given
	// ConsensusDeployment has ended or not.
	DeploymentEnder ConsensusDeploymentEnder
}

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

type ConsensusDeploymentEnder 

type ConsensusDeploymentEnder interface {
	// HasEnded returns true if the consensus deployment has ended.
	HasEnded(*wire.BlockHeader, int32) (bool, error)
}

ConsensusDeploymentEnder determines if a given consensus deployment has ended. A deployment has ended once according got eh current "time", the deployment is no longer eligible for activation.

type ConsensusDeploymentStarter 

type ConsensusDeploymentStarter interface {
	// HasStarted returns true if the consensus deployment has started.
	HasStarted(*wire.BlockHeader, int32) (bool, error)
}

ConsensusDeploymentStarter determines if a given consensus deployment has started. A deployment has started once according to the current "time", the deployment is eligible for activation once a perquisite condition has passed.

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 MedianTimeDeploymentEnder 

type MedianTimeDeploymentEnder struct {
	// contains filtered or unexported fields
}

MedianTimeDeploymentEnder is a ClockConsensusDeploymentEnder that uses the median time past of a target block to determine if a deployment has ended.

func NewMedianTimeDeploymentEnder 

func NewMedianTimeDeploymentEnder(endTime time.Time) *MedianTimeDeploymentEnder

NewMedianTimeDeploymentEnder returns a new instance of the MedianTimeDeploymentEnder anchored around the passed endTime. Using a time.Time instance where IsZero() is true, indicates that a deployment should be considered to never end.

func (*MedianTimeDeploymentEnder) EndTime 

func (m *MedianTimeDeploymentEnder) EndTime() time.Time

MedianTimeDeploymentEnder returns the raw end time of the deployment.

func (*MedianTimeDeploymentEnder) HasEnded 

func (m *MedianTimeDeploymentEnder) HasEnded(
	blkHeader *wire.BlockHeader, blkHeight int32) (bool, error)

HasEnded returns true if the deployment has ended.

func (*MedianTimeDeploymentEnder) SynchronizeClock 

func (m *MedianTimeDeploymentEnder) SynchronizeClock(clock BlockClock)

SynchronizeClock synchronizes the target ConsensusDeploymentEnder with the current up-to date BlockClock.

type MedianTimeDeploymentStarter 

type MedianTimeDeploymentStarter struct {
	// contains filtered or unexported fields
}

MedianTimeDeploymentStarter is a ClockConsensusDeploymentStarter that uses the median time past of a target block node to determine if a deployment has started.

func NewMedianTimeDeploymentStarter 

func NewMedianTimeDeploymentStarter(startTime time.Time) *MedianTimeDeploymentStarter

NewMedianTimeDeploymentStarter returns a new instance of a MedianTimeDeploymentStarter for a given start time. Using a time.Time instance where IsZero() is true, indicates that a deployment should be considered to always have been started.

func (*MedianTimeDeploymentStarter) HasStarted 

func (m *MedianTimeDeploymentStarter) HasStarted(
	blkHeader *wire.BlockHeader, blkHeight int32) (bool, error)

HasStarted returns true if the consensus deployment has started.

func (*MedianTimeDeploymentStarter) StartTime 

func (m *MedianTimeDeploymentStarter) StartTime() time.Time

StartTime returns the raw start time of the deployment.

func (*MedianTimeDeploymentStarter) SynchronizeClock 

func (m *MedianTimeDeploymentStarter) SynchronizeClock(clock BlockClock)

SynchronizeClock synchronizes the target ConsensusDeploymentStarter with the current up-to date BlockClock.

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

	// PoWNoRetargeting defines whether the network has difficulty
	// retargeting enabled or not. This should only be set to true for
	// regtest like networks.
	PoWNoRetargeting bool

	// These fields define the block heights at which the specified softfork
	// BIP became active.
	BIP0034Height int32
	BIP0065Height int32
	BIP0066Height int32

	// CoinbaseMaturity is the number of blocks required before newly mined
	// coins (coinbase transactions) can be spent.
	CoinbaseMaturity uint16

	// MwebPegoutMaturity is the number of blocks required before coins
	// pegged-out from MWEB can be spent.
	MwebPegoutMaturity 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

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

	// Human-readable part for Bech32 encoded segwit addresses, as defined
	// in BIP 173.
	Bech32HRPSegwit string

	// Human-readable part for Bech32 encoded mweb addresses.
	Bech32HRPMweb string

	// 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
	WitnessPubKeyHashAddrID byte // First byte of a P2WPKH address
	WitnessScriptHashAddrID byte // First byte of a P2WSH 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
}

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

func CustomSignetParams 

func CustomSignetParams(challenge []byte, dnsSeeds []DNSSeed) Params

CustomSignetParams creates network parameters for a custom signet network from a challenge. The challenge is the binary compiled version of the block challenge script.

Source Files

View all Source files

Directories

Path Synopsis
chainhash module

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.