9cdc1b8afd
Now that all softforking is done via BIP0009 versionbits, replace the old isMajorityVersion deployment mechanism with hard coded historical block heights at which they became active. Since the activation heights vary per network, this adds new parameters to the chaincfg.Params struct for them and sets the correct heights at which each softfork became active on each chain. It should be noted that this is a technically hard fork since the behavior of alternate chain history is different with these hard-coded activation heights as opposed to the old isMajorityVersion code. In particular, an alternate chain history could activate one of the soft forks earlier than these hard-coded heights which means the old code would reject blocks which violate the new soft fork rules whereas this new code would not. However, all of the soft forks this refers to were activated so far in the chain history there is there is no way a reorg that long could happen and checkpoints reject alternate chains before the most recent checkpoint anyways. Furthermore, the same change was made in Bitcoin Core so this needs to be changed to be consistent anyways.
135 lines
4.8 KiB
Go
135 lines
4.8 KiB
Go
// Copyright (c) 2016 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package fullblocktests
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"math/big"
|
|
"time"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg"
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
)
|
|
|
|
// newHashFromStr converts the passed big-endian hex string into a
|
|
// wire.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 {
|
|
panic(err)
|
|
}
|
|
return hash
|
|
}
|
|
|
|
// fromHex converts the passed hex string into a byte slice and will panic if
|
|
// there is an error. This is only provided for the hard-coded constants so
|
|
// errors in the source code can be detected. It will only (and must only) be
|
|
// called for initialization purposes.
|
|
func fromHex(s string) []byte {
|
|
r, err := hex.DecodeString(s)
|
|
if err != nil {
|
|
panic("invalid hex in source file: " + s)
|
|
}
|
|
return r
|
|
}
|
|
|
|
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)
|
|
|
|
// 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)
|
|
|
|
// regTestGenesisBlock defines the genesis block of the block chain which serves
|
|
// as the public transaction ledger for the regression test network.
|
|
regTestGenesisBlock = wire.MsgBlock{
|
|
Header: wire.BlockHeader{
|
|
Version: 1,
|
|
PrevBlock: *newHashFromStr("0000000000000000000000000000000000000000000000000000000000000000"),
|
|
MerkleRoot: *newHashFromStr("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"),
|
|
Timestamp: time.Unix(1296688602, 0), // 2011-02-02 23:16:42 +0000 UTC
|
|
Bits: 0x207fffff, // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
|
|
Nonce: 2,
|
|
},
|
|
Transactions: []*wire.MsgTx{{
|
|
Version: 1,
|
|
TxIn: []*wire.TxIn{{
|
|
PreviousOutPoint: wire.OutPoint{
|
|
Hash: chainhash.Hash{},
|
|
Index: 0xffffffff,
|
|
},
|
|
SignatureScript: fromHex("04ffff001d010445" +
|
|
"5468652054696d65732030332f4a616e2f" +
|
|
"32303039204368616e63656c6c6f72206f" +
|
|
"6e206272696e6b206f66207365636f6e64" +
|
|
"206261696c6f757420666f72206261686b73"),
|
|
Sequence: 0xffffffff,
|
|
}},
|
|
TxOut: []*wire.TxOut{{
|
|
Value: 0,
|
|
PkScript: fromHex("4104678afdb0fe5548271967f1" +
|
|
"a67130b7105cd6a828e03909a67962e0ea1f" +
|
|
"61deb649f6bc3f4cef38c4f35504e51ec138" +
|
|
"c4f35504e51ec112de5c384df7ba0b8d578a" +
|
|
"4c702b6bf11d5fac"),
|
|
}},
|
|
LockTime: 0,
|
|
}},
|
|
}
|
|
)
|
|
|
|
// regressionNetParams defines the network parameters for the regression test
|
|
// network.
|
|
//
|
|
// NOTE: The test generator intentionally does not use the existing definitions
|
|
// in the chaincfg package since the intent is to be able to generate known
|
|
// good tests which exercise that code. Using the chaincfg parameters would
|
|
// allow them to change out from under the tests potentially invalidating them.
|
|
var regressionNetParams = &chaincfg.Params{
|
|
Name: "regtest",
|
|
Net: wire.TestNet,
|
|
DefaultPort: "18444",
|
|
|
|
// Chain parameters
|
|
GenesisBlock: ®TestGenesisBlock,
|
|
GenesisHash: newHashFromStr("5bec7567af40504e0994db3b573c186fffcc4edefe096ff2e58d00523bd7e8a6"),
|
|
PowLimit: regressionPowLimit,
|
|
PowLimitBits: 0x207fffff,
|
|
CoinbaseMaturity: 100,
|
|
BIP0034Height: 100000000, // Not active - Permit ver 1 blocks
|
|
BIP0065Height: 1351, // Used by regression tests
|
|
BIP0066Height: 1251, // Used by regression tests
|
|
SubsidyReductionInterval: 150,
|
|
TargetTimespan: time.Hour * 24 * 14, // 14 days
|
|
TargetTimePerBlock: time.Minute * 10, // 10 minutes
|
|
RetargetAdjustmentFactor: 4, // 25% less, 400% more
|
|
ReduceMinDifficulty: true,
|
|
MinDiffReductionTime: time.Minute * 20, // TargetTimePerBlock * 2
|
|
GenerateSupported: true,
|
|
|
|
// Checkpoints ordered from oldest to newest.
|
|
Checkpoints: nil,
|
|
|
|
// Mempool parameters
|
|
RelayNonStdTxs: true,
|
|
|
|
// 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,
|
|
}
|