// Copyright (c) 2014-2016 The btcsuite developers // Use of this source code is governed by an ISC // license that can be found in the LICENSE file. package chaincfg import ( "encoding/binary" "encoding/hex" "errors" "math" "math/big" "strings" "time" "github.com/lbryio/lbcd/chaincfg/chainhash" "github.com/lbryio/lbcd/wire" ) // These variables are the chain proof-of-work limit parameters for each default // network. var ( // bigOne is 1 represented as a big.Int. It is defined here to avoid // the overhead of creating it multiple times. bigOne = big.NewInt(1) // mainPowLimit is the highest proof of work value a Bitcoin block can // have for the main network. It is the value 2^240 - 1. mainPowLimit = new(big.Int).Sub(new(big.Int).Lsh(bigOne, 240), bigOne) // regressionPowLimit is the highest proof of work value a Bitcoin block // can have for the regression test network. It is the value 2^255 - 1. regressionPowLimit = new(big.Int).Sub(new(big.Int).Lsh(bigOne, 255), bigOne) // testNet3PowLimit is the highest proof of work value a Bitcoin block // can have for the test network (version 3). It is the value // 2^240 - 1. testNet3PowLimit = new(big.Int).Sub(new(big.Int).Lsh(bigOne, 240), bigOne) // simNetPowLimit is the highest proof of work value a Bitcoin block // can have for the simulation test network. It is the value 2^255 - 1. simNetPowLimit = new(big.Int).Sub(new(big.Int).Lsh(bigOne, 255), bigOne) // sigNetPowLimit is the highest proof of work value a bitcoin block can // have for the signet test network. It is the value 0x0377ae << 216. sigNetPowLimit = new(big.Int).Lsh(new(big.Int).SetInt64(0x0377ae), 216) // DefaultSignetChallenge is the byte representation of the signet // challenge for the default (public, Taproot enabled) signet network. // This is the binary equivalent of the bitcoin 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:39246", false}, } ) // 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 Checkpoint struct { Height int32 Hash *chainhash.Hash } // DNSSeed identifies a DNS seed. 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 } // ConsensusDeployment defines details related to a specific consensus rule // change that is voted in. This is part of BIP0009. 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 // ForceActiveAt is added by LBRY to bypass consensus. Features are activated via hard-fork instead. ForceActiveAt int32 } // 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. 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 // 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 // NOTE: DefinedDeployments must always come last since it is used to // determine how many defined deployments there currently are. // DefinedDeployments is the number of currently defined deployments. DefinedDeployments ) // 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. 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 // 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 // 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 // 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 // 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 } // MainNetParams defines the network parameters for the main Bitcoin network. var MainNetParams = Params{ Name: "mainnet", Net: wire.MainNet, DefaultPort: "9246", DNSSeeds: []DNSSeed{ {"dnsseed1.lbry.com", true}, {"dnsseed2.lbry.com", true}, {"dnsseed3.lbry.com", true}, {"seed.lbry.grin.io", true}, {"seed.allaboutlbc.com", true}, }, // Chain parameters GenesisBlock: &genesisBlock, GenesisHash: &genesisHash, PowLimit: mainPowLimit, PowLimitBits: 0x1f00ffff, BIP0034Height: 1, BIP0065Height: 200000, BIP0066Height: 200000, CoinbaseMaturity: 100, SubsidyReductionInterval: 1 << 5, TargetTimespan: time.Second * 150, // retarget every block TargetTimePerBlock: time.Second * 150, // 150 seconds RetargetAdjustmentFactor: 4, // 25% less, 400% more ReduceMinDifficulty: false, MinDiffReductionTime: 0, GenerateSupported: false, // Checkpoints ordered from oldest to newest. Checkpoints: []Checkpoint{ {40000, newHashFromStr("4c55584b068108b15c0066a010d11971aa92f46b0a73d479f1b7fa57df8b05f4")}, {80000, newHashFromStr("6e9facdfb87ba8394a46c61a7c093f7f00b1397a2dabc6a04f2911e0efdcf50a")}, {120000, newHashFromStr("6a9dba420ec544b927769765dccec8b29e214e6ca9f82b54a52bf20ca517b75a")}, {160000, newHashFromStr("87b2913a509d857401f7587903c90214db7847af1a1ad63a3b6f245936e3ae9d")}, {200000, newHashFromStr("0fe8ed6019a83028006435e47be4e37a0d3ed48019cde1dc7ede6562e5829839")}, {240000, newHashFromStr("cb3c2342afbe7291012f2288403a9d105f46987f78b279d516db2deb4d35b0b7")}, {280000, newHashFromStr("9835d03eb527ea4ce45c217350c68042926d497c21fb31413b2f7824ff6fc6c3")}, {320000, newHashFromStr("ad80c7cb91ca1d9c9b7bf68ca1b6d4ba217fe25ca5ded6a7e8acbaba663b143f")}, {360000, newHashFromStr("f9fd013252439663c1e729a8afb27187a8b9cc63a253336060f867e3cfbe4dcb")}, {400000, newHashFromStr("f0e56e70782af63ccb49c76e852540688755869ba59ec68cac9c04a6b4d9f5ca")}, {440000, newHashFromStr("52760e00c369b40781a2ced32836711fab82a720fafb121118c815bb46afd996")}, {480000, newHashFromStr("cecacaf4d1a8d1ef60da39343540781115abb91f5f0c976bb08afc4d4e3218ac")}, {520000, newHashFromStr("fa5e9d6dcf9ad57ba60d8ba26fb05585741098d10f42ed9d5e6b5e90ebc278d6")}, {560000, newHashFromStr("95c6229bd9b40f03a8426b2fec740026b3f06b1628cfb87527b0cbd0da328c0c")}, {600000, newHashFromStr("532657a97d480feb2d0423bb736cbfd7400b3ac8311e81ac749a2f29103a6c6b")}, {640000, newHashFromStr("68b69e3e8765e1ddbac63cbfbbf12e1a920da994d242a26fd07624f067743080")}, {680000, newHashFromStr("7b9f30c959405b5b96d0b0c2ba8fc7c5586cd0ce40df51427de4b8a217859c45")}, {720000, newHashFromStr("42084d5f88c71c0ae09b8677070969df9c3ef875c5f434133f552d863204f0cb")}, {760000, newHashFromStr("1887cd8b50375a9ac0dc9686c98fa8ac69bca618eab6254310647057f6fe4fc9")}, {800000, newHashFromStr("d34bb871b21e6fda4bd9d9e530ebf12e044814004007f088415035c651ecf322")}, {840000, newHashFromStr("d0e73c5ce3ad5d6fdb4483aa450f0b1cf7e4570987ee3a3806ace4ad2f7cc9af")}, {880000, newHashFromStr("806a95f26bab603f1d9132b5d4ea72aab9d1198ad55ae18dac1e149f6cb70ce4")}, {920000, newHashFromStr("83bc84555105436c51728ab200e8da4d9b3a365fd3d1d47a60048ad0f977c55b")}, {960000, newHashFromStr("60e37b1c2d1f8771290b7f84865cbadf22b5b89d3ce1201d454b09f0775b42c2")}, }, // Consensus rule change deployments. // // The miner confirmation window is defined as: // target proof of work timespan / target proof of work spacing RuleChangeActivationThreshold: 1916, // 95% of MinerConfirmationWindow MinerConfirmationWindow: 2016, // Deployments: [DefinedDeployments]ConsensusDeployment{ DeploymentTestDummy: { BitNumber: 28, StartTime: 1199145601, // January 1, 2008 UTC ExpireTime: 1230767999, // December 31, 2008 UTC }, DeploymentCSV: { BitNumber: 0, StartTime: 1462060800, // May 1st, 2016 ExpireTime: 1493596800, // May 1st, 2017 ForceActiveAt: 200000, }, DeploymentSegwit: { BitNumber: 1, StartTime: 1547942400, // Jan 20, 2019 ExpireTime: 1548288000, // Jan 24, 2019 ForceActiveAt: 680770, }, }, // Mempool parameters RelayNonStdTxs: false, // Human-readable part for Bech32 encoded segwit addresses, as defined in // BIP 173. Bech32HRPSegwit: "lbc", // Address encoding magics PubKeyHashAddrID: 0x55, ScriptHashAddrID: 0x7a, PrivateKeyID: 0x1c, // BIP32 hierarchical deterministic extended key magics HDPrivateKeyID: [4]byte{0x04, 0x88, 0xad, 0xe4}, HDPublicKeyID: [4]byte{0x04, 0x88, 0xb2, 0x1e}, // BIP44 coin type used in the hierarchical deterministic path for // address generation. HDCoinType: 0, } // 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". var RegressionNetParams = Params{ Name: "regtest", Net: wire.TestNet, DefaultPort: "29246", DNSSeeds: []DNSSeed{}, // Chain parameters GenesisBlock: ®TestGenesisBlock, GenesisHash: ®TestGenesisHash, PowLimit: regressionPowLimit, PowLimitBits: 0x207fffff, CoinbaseMaturity: 100, BIP0034Height: 1000, BIP0065Height: 1351, // Used by regression tests BIP0066Height: 1251, // Used by regression tests SubsidyReductionInterval: 1 << 5, TargetTimespan: time.Second, TargetTimePerBlock: time.Second, RetargetAdjustmentFactor: 4, // 25% less, 400% more ReduceMinDifficulty: false, MinDiffReductionTime: 0, GenerateSupported: true, // Checkpoints ordered from oldest to newest. Checkpoints: nil, // Consensus rule change deployments. // // The miner confirmation window is defined as: // target proof of work timespan / target proof of work spacing RuleChangeActivationThreshold: 108, // 75% of MinerConfirmationWindow MinerConfirmationWindow: 144, Deployments: [DefinedDeployments]ConsensusDeployment{ DeploymentTestDummy: { BitNumber: 28, StartTime: 0, // Always available for vote ExpireTime: math.MaxInt64, // Never expires }, DeploymentCSV: { BitNumber: 0, StartTime: 0, // Always available for vote ExpireTime: math.MaxInt64, // Never expires ForceActiveAt: 1, }, DeploymentSegwit: { BitNumber: 1, StartTime: 0, ExpireTime: math.MaxInt64, ForceActiveAt: 150, }, }, // Mempool parameters RelayNonStdTxs: true, // Human-readable part for Bech32 encoded segwit addresses, as defined in // BIP 173. Bech32HRPSegwit: "rlbc", // Address encoding magics PubKeyHashAddrID: 111, // starts with m or n ScriptHashAddrID: 196, // starts with 2 PrivateKeyID: 239, // starts with 9 (uncompressed) or c (compressed) // BIP32 hierarchical deterministic extended key magics HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94}, // starts with tprv HDPublicKeyID: [4]byte{0x04, 0x35, 0x87, 0xcf}, // starts with tpub // BIP44 coin type used in the hierarchical deterministic path for // address generation. 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". var TestNet3Params = Params{ Name: "testnet3", Net: wire.TestNet3, DefaultPort: "19246", DNSSeeds: []DNSSeed{ {"testdnsseed1.lbry.com", true}, {"testdnsseed2.lbry.com", true}, }, // Chain parameters GenesisBlock: &testNet3GenesisBlock, GenesisHash: &testNet3GenesisHash, PowLimit: testNet3PowLimit, PowLimitBits: 0x1f00ffff, BIP0034Height: 21111, // 0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8 BIP0065Height: 1200000, BIP0066Height: 1200000, CoinbaseMaturity: 100, SubsidyReductionInterval: 1 << 5, TargetTimespan: time.Second * 150, // retarget every block TargetTimePerBlock: time.Second * 150, // 150 seconds RetargetAdjustmentFactor: 4, // 25% less, 400% more ReduceMinDifficulty: false, MinDiffReductionTime: 0, GenerateSupported: true, // Checkpoints ordered from oldest to newest. Checkpoints: []Checkpoint{}, // Consensus rule change deployments. // // The miner confirmation window is defined as: // target proof of work timespan / target proof of work spacing RuleChangeActivationThreshold: 1512, // 75% of MinerConfirmationWindow MinerConfirmationWindow: 2016, Deployments: [DefinedDeployments]ConsensusDeployment{ DeploymentTestDummy: { BitNumber: 28, StartTime: 1199145601, // January 1, 2008 UTC ExpireTime: 1230767999, // December 31, 2008 UTC }, DeploymentCSV: { BitNumber: 0, StartTime: 1456790400, // March 1st, 2016 ExpireTime: 1493596800, // May 1st, 2017 }, DeploymentSegwit: { BitNumber: 1, StartTime: 1462060800, // May 1st 2016 ExpireTime: 1493596800, // May 1st 2017 ForceActiveAt: 1198600, }, }, // Mempool parameters RelayNonStdTxs: true, // Human-readable part for Bech32 encoded segwit addresses, as defined in // BIP 173. Bech32HRPSegwit: "tlbc", // Address encoding magics PubKeyHashAddrID: 111, ScriptHashAddrID: 196, PrivateKeyID: 239, // BIP32 hierarchical deterministic extended key magics HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94}, // starts with tprv HDPublicKeyID: [4]byte{0x04, 0x35, 0x87, 0xcf}, // starts with tpub // BIP44 coin type used in the hierarchical deterministic path for // address generation. HDCoinType: 1, } // 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. var SimNetParams = Params{ Name: "simnet", Net: wire.SimNet, DefaultPort: "39246", DNSSeeds: []DNSSeed{}, // NOTE: There must NOT be any seeds. // Chain parameters GenesisBlock: &simNetGenesisBlock, GenesisHash: &simNetGenesisHash, PowLimit: simNetPowLimit, PowLimitBits: 0x207fffff, BIP0034Height: 0, // Always active on simnet BIP0065Height: 0, // Always active on simnet BIP0066Height: 0, // Always active on simnet CoinbaseMaturity: 100, SubsidyReductionInterval: 210000, TargetTimespan: time.Second * 150, TargetTimePerBlock: time.Second * 150, RetargetAdjustmentFactor: 4, // 25% less, 400% more ReduceMinDifficulty: true, MinDiffReductionTime: 0, GenerateSupported: true, // Checkpoints ordered from oldest to newest. Checkpoints: nil, // Consensus rule change deployments. // // The miner confirmation window is defined as: // target proof of work timespan / target proof of work spacing RuleChangeActivationThreshold: 75, // 75% of MinerConfirmationWindow MinerConfirmationWindow: 100, Deployments: [DefinedDeployments]ConsensusDeployment{ DeploymentTestDummy: { BitNumber: 28, StartTime: 0, // Always available for vote ExpireTime: math.MaxInt64, // Never expires }, DeploymentCSV: { BitNumber: 0, StartTime: 0, // Always available for vote ExpireTime: math.MaxInt64, // Never expires }, DeploymentSegwit: { BitNumber: 1, StartTime: 0, ExpireTime: math.MaxInt64, }, }, // Mempool parameters RelayNonStdTxs: true, // Human-readable part for Bech32 encoded segwit addresses, as defined in // BIP 173. Bech32HRPSegwit: "slbc", // Address encoding magics PubKeyHashAddrID: 111, ScriptHashAddrID: 196, PrivateKeyID: 239, // BIP32 hierarchical deterministic extended key magics HDPrivateKeyID: [4]byte{0x04, 0x20, 0xb9, 0x00}, // starts with sprv HDPublicKeyID: [4]byte{0x04, 0x20, 0xbd, 0x3a}, // starts with spub // BIP44 coin type used in the hierarchical deterministic path for // address generation. HDCoinType: 115, // ASCII for s } // SigNetParams defines the network parameters for the default public signet // Bitcoin network. Not to be confused with the regression test network, this // network is sometimes simply called "signet" or "taproot signet". var SigNetParams = CustomSignetParams( DefaultSignetChallenge, DefaultSignetDNSSeeds, ) // CustomSignetParams creates network parameters for a custom signet network // from a challenge. The challenge is the binary compiled version of the block // challenge script. func CustomSignetParams(challenge []byte, dnsSeeds []DNSSeed) Params { // The message start is defined as the first four bytes of the sha256d // of the challenge script, as a single push (i.e. prefixed with the // challenge script length). challengeLength := byte(len(challenge)) hashDouble := chainhash.DoubleHashB( append([]byte{challengeLength}, challenge...), ) // We use little endian encoding of the hash prefix to be in line with // the other wire network identities. net := binary.LittleEndian.Uint32(hashDouble[0:4]) return Params{ Name: "signet", Net: wire.BitcoinNet(net), DefaultPort: "39246", DNSSeeds: dnsSeeds, // Chain parameters GenesisBlock: &sigNetGenesisBlock, GenesisHash: &sigNetGenesisHash, PowLimit: sigNetPowLimit, PowLimitBits: 0x1e0377ae, BIP0034Height: 1, BIP0065Height: 1, BIP0066Height: 1, CoinbaseMaturity: 100, SubsidyReductionInterval: 210000, TargetTimespan: time.Hour * 24 * 14, // 14 days TargetTimePerBlock: time.Minute * 10, // 10 minutes RetargetAdjustmentFactor: 4, // 25% less, 400% more ReduceMinDifficulty: false, MinDiffReductionTime: time.Minute * 20, // TargetTimePerBlock * 2 GenerateSupported: false, // Checkpoints ordered from oldest to newest. Checkpoints: nil, // Consensus rule change deployments. // // The miner confirmation window is defined as: // target proof of work timespan / target proof of work spacing RuleChangeActivationThreshold: 1916, // 95% of 2016 MinerConfirmationWindow: 2016, Deployments: [DefinedDeployments]ConsensusDeployment{ DeploymentTestDummy: { BitNumber: 28, StartTime: 1199145601, // January 1, 2008 UTC ExpireTime: 1230767999, // December 31, 2008 UTC }, DeploymentCSV: { BitNumber: 29, StartTime: 0, // Always available for vote ExpireTime: math.MaxInt64, // Never expires }, DeploymentSegwit: { BitNumber: 29, StartTime: 0, // Always available for vote ExpireTime: math.MaxInt64, // Never expires. }, DeploymentTaproot: { BitNumber: 29, StartTime: 0, // Always available for vote ExpireTime: math.MaxInt64, // Never expires. }, }, // Mempool parameters RelayNonStdTxs: false, // Human-readable part for Bech32 encoded segwit addresses, as defined in // BIP 173. Bech32HRPSegwit: "slbc", // Address encoding magics PubKeyHashAddrID: 0x6f, // starts with m or n ScriptHashAddrID: 0xc4, // starts with 2 PrivateKeyID: 0xef, // starts with 9 (uncompressed) or c (compressed) // BIP32 hierarchical deterministic extended key magics HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94}, // starts with tprv HDPublicKeyID: [4]byte{0x04, 0x35, 0x87, 0xcf}, // starts with tpub // BIP44 coin type used in the hierarchical deterministic path for // address generation. HDCoinType: 1, } } 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") // 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") ) var ( registeredNets = make(map[wire.BitcoinNet]struct{}) pubKeyHashAddrIDs = make(map[byte]struct{}) scriptHashAddrIDs = make(map[byte]struct{}) bech32SegwitPrefixes = make(map[string]struct{}) hdPrivToPubKeyIDs = make(map[[4]byte][]byte) ) // String returns the hostname of the DNS seed in human-readable form. func (d DNSSeed) String() string { return d.Host } // 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. func Register(params *Params) error { if _, ok := registeredNets[params.Net]; ok { return ErrDuplicateNet } registeredNets[params.Net] = struct{}{} pubKeyHashAddrIDs[params.PubKeyHashAddrID] = struct{}{} scriptHashAddrIDs[params.ScriptHashAddrID] = struct{}{} err := RegisterHDKeyID(params.HDPublicKeyID[:], params.HDPrivateKeyID[:]) if err != nil { return err } // A valid Bech32 encoded segwit address always has as prefix the // human-readable part for the given net followed by '1'. bech32SegwitPrefixes[params.Bech32HRPSegwit+"1"] = struct{}{} return nil } // mustRegister performs the same function as Register except it panics if there // is an error. This should only be called from package init functions. func mustRegister(params *Params) { if err := Register(params); err != nil { panic("failed to register network: " + err.Error()) } } // 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 IsPubKeyHashAddrID(id byte) bool { _, ok := pubKeyHashAddrIDs[id] return ok } // 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 IsScriptHashAddrID(id byte) bool { _, ok := scriptHashAddrIDs[id] return ok } // 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 IsBech32SegwitPrefix(prefix string) bool { prefix = strings.ToLower(prefix) _, ok := bech32SegwitPrefixes[prefix] return ok } // 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 func RegisterHDKeyID(hdPublicKeyID []byte, hdPrivateKeyID []byte) error { if len(hdPublicKeyID) != 4 || len(hdPrivateKeyID) != 4 { return ErrInvalidHDKeyID } var keyID [4]byte copy(keyID[:], hdPrivateKeyID) hdPrivToPubKeyIDs[keyID] = hdPublicKeyID return nil } // 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 HDPrivateKeyToPublicKeyID(id []byte) ([]byte, error) { if len(id) != 4 { return nil, ErrUnknownHDKeyID } var key [4]byte copy(key[:], id) pubBytes, ok := hdPrivToPubKeyIDs[key] if !ok { return nil, ErrUnknownHDKeyID } return pubBytes, nil } // newHashFromStr converts the passed big-endian hex string into a // chainhash.Hash. It only differs from the one available in chainhash in that // it panics on an error since it will only (and must only) be called with // hard-coded, and therefore known good, hashes. func newHashFromStr(hexStr string) *chainhash.Hash { hash, err := chainhash.NewHashFromStr(hexStr) if err != nil { // Ordinarily I don't like panics in library code since it // can take applications down without them having a chance to // recover which is extremely annoying, however an exception is // being made in this case because the only way this can panic // is if there is an error in the hard-coded hashes. Thus it // will only ever potentially panic on init and therefore is // 100% predictable. panic(err) } return hash } func init() { // Register all default networks when the package is initialized. mustRegister(&MainNetParams) mustRegister(&TestNet3Params) mustRegister(&RegressionNetParams) mustRegister(&SimNetParams) }