fork

package
v1.9.16 Latest Latest
Warning

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

 Go to latest Published: Mar 4, 2021 License: Unlicense Imports: 8 Imported by: 0

Documentation

Overview

Package fork handles tracking the hard fork status and is used to determine which consensus rules apply on a block

Index

Constants

View Source 
const (
	Scrypt  = "scrypt"
	SHA256d = "sha256d"
)

Variables

View Source 
var (
	AlgoSlices []AlgoSpecs
	// AlgoVers is the lookup for pre hardfork
	//
	AlgoVers = map[int32]string{
		2:   SHA256d,
		514: Scrypt,
	}
	// Algos are the specifications identifying the algorithm used in the
	// block proof
	Algos = map[string]AlgoParams{
		AlgoVers[2]: {
			Version: 2,
			MinBits: MainPowLimitBits,
		},
		AlgoVers[514]: {
			Version: 514,
			MinBits: MainPowLimitBits,
			AlgoID:  1,
		},
	}
	// FirstPowLimit is
	FirstPowLimit = func() big.Int {
		mplb, _ := hex.DecodeString(
			"0fffff0000000000000000000000000000000000000000000000000000000000",
		)
		return *big.NewInt(0).SetBytes(mplb)
	}()
	// FirstPowLimitBits is
	FirstPowLimitBits = BigToCompact(&FirstPowLimit)
	// IsTestnet is set at startup here to be accessible to all other libraries
	IsTestnet bool
	// List is the list of existing hard forks and when they activate
	List = []HardForks{
		{
			Number:             0,
			Name:               "Halcyon days",
			ActivationHeight:   0,
			Algos:              Algos,
			AlgoVers:           AlgoVers,
			TargetTimePerBlock: 300,
			AveragingInterval:  10,
			TestnetStart:       0,
		},
		{
			Number:             1,
			Name:               "Plan 9 from Crypto Space",
			ActivationHeight:   2500000,
			Algos:              P9Algos,
			AlgoVers:           P9AlgoVers,
			TargetTimePerBlock: 36,
			AveragingInterval:  3600,
			TestnetStart:       1,
		},
	}
	// P9AlgoVers is the lookup for after 1st hardfork
	P9AlgoVers = make(map[int32]string)

	P9PrimeSequence = []int{2, 3, 5, 7, 11, 13, 17, 19, 23}
	IntervalDivisor = 1
	IntervalBase    = 101
	// P9Algos is the algorithm specifications after the hard fork
	P9Algos        = make(map[string]AlgoParams)
	P9AlgosNumeric = map[int32]AlgoParams{
		5:  {5, FirstPowLimitBits, 0, IntervalBase * P9PrimeSequence[0] / IntervalDivisor},
		6:  {6, FirstPowLimitBits, 1, IntervalBase * P9PrimeSequence[1] / IntervalDivisor},
		7:  {7, FirstPowLimitBits, 2, IntervalBase * P9PrimeSequence[2] / IntervalDivisor},
		8:  {8, FirstPowLimitBits, 3, IntervalBase * P9PrimeSequence[3] / IntervalDivisor},
		9:  {9, FirstPowLimitBits, 4, IntervalBase * P9PrimeSequence[4] / IntervalDivisor},
		10: {10, FirstPowLimitBits, 5, IntervalBase * P9PrimeSequence[5] / IntervalDivisor},
		11: {11, FirstPowLimitBits, 7, IntervalBase * P9PrimeSequence[7] / IntervalDivisor},
		12: {12, FirstPowLimitBits, 6, IntervalBase * P9PrimeSequence[6] / IntervalDivisor},
		13: {13, FirstPowLimitBits, 8, IntervalBase * P9PrimeSequence[8] / IntervalDivisor},
	}

	P9Average float64

	// SecondPowLimit is
	SecondPowLimit = func() big.Int {
		mplb, _ := hex.DecodeString(

			"0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
		)
		return *big.NewInt(0).SetBytes(mplb)
	}()
	SecondPowLimitBits = BigToCompact(&SecondPowLimit)
	MainPowLimit       = func() big.Int {
		mplb, _ := hex.DecodeString(
			"00000fffff000000000000000000000000000000000000000000000000000000",
		)
		return *big.NewInt(0).SetBytes(mplb)
	}()
	MainPowLimitBits = BigToCompact(&MainPowLimit)
)

Functions

func AlgoVerIterator added in v1.9.16 

func AlgoVerIterator(height int32) (next func(), curr func() int32, more func() bool)

AlgoVerIterator returns a next and more function to use in a for loop to iterate over block versions at current height

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 Check added in v0.4.14 

func Check(err error) bool

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 Debug added in v0.4.14 

func Debug(a ...interface{})

func Debugc added in v0.4.14 

func Debugc(fn func() string)

func Debugf added in v0.4.14 

func Debugf(format string, a ...interface{})

func Debugs added in v0.4.14 

func Debugs(a interface{})

func Error added in v0.4.14 

func Error(a ...interface{})

func Errorc added in v0.4.14 

func Errorc(fn func() string)

func Errorf added in v0.4.14 

func Errorf(format string, a ...interface{})

func Errors added in v0.4.14 

func Errors(a interface{})

func Fatal added in v0.4.14 

func Fatal(a ...interface{})

func Fatalc added in v0.4.14 

func Fatalc(fn func() string)

func Fatalf added in v0.4.14 

func Fatalf(format string, a ...interface{})

func Fatals added in v0.4.14 

func Fatals(a interface{})

func GetAlgoID 

func GetAlgoID(algoname string, height int32) uint32

GetAlgoID returns the 'algo_id' which in pre-hardfork is not the same as the block version number, but is afterwards

func GetAlgoName 

func GetAlgoName(algoVer int32, height int32) (name string)

GetAlgoName returns the string identifier of an algorithm depending on hard fork activation status

func GetAlgoVer 

func GetAlgoVer(name string, height int32) (version int32)

GetAlgoVer returns the version number for a given algorithm (by string name) at a given height. If "random" is given, a random number is taken from the system secure random source (for randomised cpu mining)

func GetAlgoVerSlice added in v1.9.16 

func GetAlgoVerSlice(height int32) (o []int32)

func GetAlgos added in v1.9.16 

func GetAlgos(height int32) (o map[string]AlgoParams)

GetAlgos returns the map of names and algorithm parameters

func GetAveragingInterval 

func GetAveragingInterval(height int32) (r int32)

GetAveragingInterval returns the active block interval target based on hard fork status

func GetCurrent 

func GetCurrent(height int32) (curr int)

GetCurrent returns the hardfork number code

func GetMinBits 

func GetMinBits(algoname string, height int32) (mb uint32)

GetMinBits returns the minimum diff bits based on height and testnet

func GetMinDiff 

func GetMinDiff(algoname string, height int32) (md *big.Int)

GetMinDiff returns the minimum difficulty in uint256 form

func GetNumAlgos added in v1.9.16 

func GetNumAlgos(height int32) (numAlgos int)

GetNumAlgos returns the number of algos at a given height

func GetRandomVersion added in v0.4.14 

func GetRandomVersion(height int32) int32

GetRandomVersion returns a random version relevant to the current hard fork state and height

func GetTargetTimePerBlock 

func GetTargetTimePerBlock(height int32) (r int64)

GetTargetTimePerBlock returns the active block interval target based on hard fork status

func Info added in v0.4.14 

func Info(a ...interface{})

func Infoc added in v0.4.14 

func Infoc(fn func() string)

func Infof added in v0.4.14 

func Infof(format string, a ...interface{})

func Infos added in v0.4.14 

func Infos(a interface{})

func Trace added in v0.4.14 

func Trace(a ...interface{})

func Tracec added in v0.4.14 

func Tracec(fn func() string)

func Tracef added in v0.4.14 

func Tracef(format string, a ...interface{})

func Traces added in v0.4.14 

func Traces(a interface{})

func Warn added in v0.4.14 

func Warn(a ...interface{})

func Warnc added in v0.4.14 

func Warnc(fn func() string)

func Warnf added in v0.4.14 

func Warnf(format string, a ...interface{})

func Warns added in v0.4.14 

func Warns(a interface{})

Types

type AlgoParams 

type AlgoParams struct {
	Version         int32
	MinBits         uint32
	AlgoID          uint32
	VersionInterval int
}

AlgoParams are the identifying block version number and their minimum target bits

type AlgoSpec added in v0.4.14 

type AlgoSpec struct {
	Version int32
	Name    string
}

type AlgoSpecs added in v0.4.14 

type AlgoSpecs []AlgoSpec

func (AlgoSpecs) Len added in v0.4.14 

func (a AlgoSpecs) Len() int

func (AlgoSpecs) Less added in v0.4.14 

func (a AlgoSpecs) Less(i, j int) bool

func (AlgoSpecs) Swap added in v0.4.14 

func (a AlgoSpecs) Swap(i, j int)

type HardForks 

type HardForks struct {
	Number             int
	ActivationHeight   int32
	Name               string
	Algos              map[string]AlgoParams
	AlgoVers           map[int32]string
	TargetTimePerBlock int32
	AveragingInterval  int32
	TestnetStart       int32
}

HardForks is the details related to a hard fork, number, name and activation height

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.