fork.go

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

import (
	"encoding/hex"
	"fmt"
	"math/big"
	"math/rand"
	"sort"
	"time"

	"github.com/cybriq/p9/pkg/bits"
	"github.com/cybriq/p9/pkg/log"
)

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

// AlgoParams are the identifying block version number and their minimum target bits
type AlgoParams struct {
	Version         int32
	MinBits         uint32
	AlgoID          uint32
	VersionInterval int
}

// HardForks is the details related to a hard fork, number, name and activation height
type HardForks struct {
	Number             int
	ActivationHeight   int32
	Name               string
	Algos              map[string]AlgoParams
	AlgoVers           map[int32]string
	TargetTimePerBlock int32
	AveragingInterval  int32
	TestnetStart       int32
}

type AlgoSpec struct {
	Version int32
	Name    string
}
type AlgoSpecs []AlgoSpec

func (a AlgoSpecs) Len() int {
	return len(a)
}

func (a AlgoSpecs) Less(i, j int) bool {
	return a[i].Version > a[j].Version
}

func (a AlgoSpecs) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}

func init() {
	ForkCalc()
}

var done bool

func ForkCalc() {
	if done {
		I.Ln(log.Caller("called again", 1))
		return
	}
	done = true
	T.Ln("running fork data init")
	for i := range P9AlgosNumeric {
		List[1].AlgoVers[i] = fmt.Sprintf(
			"Div%d",
			P9AlgosNumeric[i].VersionInterval,
		)
	}
	for i, v := range P9AlgoVers {
		List[1].Algos[v] = P9AlgosNumeric[i]
	}
	AlgoSlices = append(AlgoSlices, AlgoSpecs{})
	for i := range Algos {
		AlgoSlices[0] = append(
			AlgoSlices[0], AlgoSpec{
				List[0].Algos[i].Version,
				i,
			},
		)
	}
	AlgoSlices = append(AlgoSlices, AlgoSpecs{})
	for i := range P9Algos {
		AlgoSlices[1] = append(
			AlgoSlices[1], AlgoSpec{
				List[1].Algos[i].Version,
				i,
			},
		)
	}
	sort.Sort(AlgoSlices[0])
	sort.Sort(AlgoSlices[1])
	D.Ln(P9AlgoVers)
	baseVersionName := AlgoSlices[1][0].Name
	baseVersionInterval := float64(P9Algos[baseVersionName].VersionInterval)
	D.Ln(baseVersionName, baseVersionInterval)
	P9Average = 0
	for _, i := range AlgoSlices[1] {
		vi := float64(P9Algos[i.Name].VersionInterval)
		p9a := baseVersionInterval / vi
		P9Average += p9a
		// Tracef("P9Average %4.4f %4.4f %d %4.4f", p9a, P9Average, IntervalBase, vi)
	}
	D.Ln(P9Average)
	P9Average = baseVersionInterval / P9Average
	D.Ln(P9Average)
}

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 = bits.BigToCompact(&FirstPowLimit)

	p9PowLimit = func() big.Int {
		mplb, _ := hex.DecodeString(
			// "0fffff0000000000000000000000000000000000000000000000000000000000",
			"efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
		)
		return *big.NewInt(0).SetBytes(mplb)
	}()
	p9PowLimitBits = bits.BigToCompact(&p9PowLimit)
	// 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, // 50 minutes
			TestnetStart:       0,
		},
		{
			Number:             1,
			Name:               "Plan 9 from Crypto Space",
			ActivationHeight:   25000000,
			Algos:              P9Algos,
			AlgoVers:           P9AlgoVers,
			TargetTimePerBlock: 36,
			AveragingInterval:  3600,
			TestnetStart:       0,
		},
	}
	// P9AlgoVers is the lookup for after 1st hardfork
	P9AlgoVers = make(map[int32]string)

	// DoublingSequence is the differential between different block versions and
	// their relative block timing
	DoublingSequence = []int{2, 4, 8, 16, 32, 64, 128, 256, 512}
	IntervalDivisor  = 1
	IntervalBase     = 9
	// P9Algos is the algorithm specifications after the hard fork
	P9Algos        = make(map[string]AlgoParams)
	P9AlgosNumeric = map[int32]AlgoParams{
		5: {
			5, p9PowLimitBits, 0,
			IntervalBase * DoublingSequence[0] / IntervalDivisor,
		}, // 2
		6: {
			6, p9PowLimitBits, 1,
			IntervalBase * DoublingSequence[1] / IntervalDivisor,
		}, // 3
		7: {
			7, p9PowLimitBits, 2,
			IntervalBase * DoublingSequence[2] / IntervalDivisor,
		}, // 5
		8: {
			8, p9PowLimitBits, 3,
			IntervalBase * DoublingSequence[3] / IntervalDivisor,
		}, // 7
		9: {
			9, p9PowLimitBits, 4,
			IntervalBase * DoublingSequence[4] / IntervalDivisor,
		}, // 11
		10: {
			10, p9PowLimitBits, 5,
			IntervalBase * DoublingSequence[5] / IntervalDivisor,
		}, // 13
		11: {
			11, p9PowLimitBits, 7,
			IntervalBase * DoublingSequence[7] / IntervalDivisor,
		}, // 17
		12: {
			12, p9PowLimitBits, 6,
			IntervalBase * DoublingSequence[6] / IntervalDivisor,
		}, // 19
		13: {
			13, p9PowLimitBits, 8,
			IntervalBase * DoublingSequence[8] / IntervalDivisor,
		}, // 23
	}

	P9Average float64

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

// GetAlgoID returns the 'algo_id' which in pre-hardfork is not the same as the block version number, but is afterwards
func GetAlgoID(algoname string, height int32) uint32 {
	if GetCurrent(height) > 1 {
		return P9Algos[algoname].AlgoID
	}
	return Algos[algoname].AlgoID
}

// GetAlgoName returns the string identifier of an algorithm depending on
// hard fork activation status
func GetAlgoName(algoVer int32, height int32) (name string) {
	hf := GetCurrent(height)
	var ok bool
	name, ok = List[hf].AlgoVers[algoVer]
	if hf < 1 && !ok {
		name = SHA256d
	}
	// I.Ln("GetAlgoName", algoVer, height, name}
	return
}

// GetRandomVersion returns a random version relevant to the current hard fork state and height
func GetRandomVersion(height int32) int32 {
	rand.Seed(time.Now().UnixNano())
	return int32(rand.Intn(len(List[GetCurrent(height)].Algos)) + 5)
}

// 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 GetAlgoVer(name string, height int32) (version int32) {
	hf := GetCurrent(height)
	n := AlgoSlices[hf][0].Name
	// D.Ln("GetAlgoVer", name, height, hf, n)
	if _, ok := List[hf].Algos[name]; ok {
		n = name
	}
	version = List[hf].Algos[n].Version
	return
}

var algoVerSlice [][]int32

func GetAlgoVerSlice(height int32) (o []int32) {
	hf := GetCurrent(height)
	if algoVerSlice == nil {
		algoVerSlice = make([][]int32, 0, len(List))
		for i := range List {
			av := make([]int32, 0, len(List[i].AlgoVers))
			for j := range List[i].AlgoVers {
				av = append(av, j)
			}
			algoVerSlice = append(algoVerSlice, av)
		}
	}
	// D.S(algoVerSlice)
	return algoVerSlice[hf]
}

// AlgoVerIterator returns a next and more function to use in a for loop to
// iterate over block versions at current height
func AlgoVerIterator(height int32) (
	next func(), curr func() int32,
	more func() bool,
) {
	current := GetCurrent(height)
	var cursor int32
	length := int32(GetNumAlgos(height))
	var verNumbers []int32
	for i := range List[current].AlgoVers {
		verNumbers = append(
			verNumbers,
			List[current].Algos[List[current].AlgoVers[i]].Version,
		)
	}
	curr = func() int32 {
		return verNumbers[cursor]
	}
	more = func() bool {
		return cursor < length
	}
	next = func() {
		if more() {
			cursor++
		}
	}

	return
}

// GetAlgos returns the map of names and algorithm parameters
func GetAlgos(height int32) (o map[string]AlgoParams) {
	current := GetCurrent(height)
	for i := range List {
		if List[i].Number == current {
			o = List[i].Algos
			break
		}
	}
	return
}

// GetNumAlgos returns the number of algos at a given height
func GetNumAlgos(height int32) (numAlgos int) {
	current := GetCurrent(height)
	for i := range List {
		if List[i].Number == current {
			numAlgos = len(List[i].Algos)
			break
		}
	}
	return
}

// GetAveragingInterval returns the active block interval target based on hard fork status
func GetAveragingInterval(height int32) (r int32) {
	r = List[GetCurrent(height)].AveragingInterval
	return
}

// GetCurrent returns the hardfork number code
func GetCurrent(height int32) (curr int) {
	// F.Ln("istestnet", IsTestnet)
	if IsTestnet {
		for i := range List {
			if height >= List[i].TestnetStart {
				curr = i
			}
		}
	} else {
		for i := range List {
			if height >= List[i].ActivationHeight {
				curr = i
			}
		}
	}
	return
}

// GetMinBits returns the minimum diff bits based on height and testnet
func GetMinBits(algoname string, height int32) (mb uint32) {
	curr := GetCurrent(height)
	// F.Ln("GetMinBits", algoname, height, curr, List[curr].Algos)
	mb = List[curr].Algos[algoname].MinBits
	// TraceF("minbits %08x, %d", mb, mb)
	return
}

// GetMinDiff returns the minimum difficulty in uint256 form
func GetMinDiff(algoname string, height int32) (md *big.Int) {
	// F.Ln("GetMinDiff", algoname)
	minbits := GetMinBits(algoname, height)
	// TraceF("mindiff minbits %08x", minbits)
	return bits.CompactToBig(minbits)
}

// GetTargetTimePerBlock returns the active block interval target based on hard fork status
func GetTargetTimePerBlock(height int32) (r int64) {
	r = int64(List[GetCurrent(height)].TargetTimePerBlock)
	return
}