Simulator # 11

package main

import (
	"flag"
	"fmt"
	"time"
	"math"
	"math/rand"
	"math/big"
	"os"
	"strconv"
)

var block = 4 //block count ( for genesis block = 0 )

var pi = float64(3.1415926535897932384626433832795)

var DCoef = new(big.Int)
var BCoef = new(big.Int)


//var coef = float64(0.43429448190325182765112891891661)
var coef = float64(4.3429448190325182765112891891661)

var year = 262980

//var percent_year = 0.0314159
var percent_year = 0.005

var percent_day_multi = math.Pow(1+percent_year, float64(1.0/365.0))
var percent = (percent_day_multi - 1) / 720.0

var Coin = int64(1000000)
var Cent = int64(10000)

var mplus, wMplus, sMplus float64

var stakeTgtSpacing = 600
var tgtTimeSpan = int64(7 * 24 * 60 * 60)

var maxWreward = float64(99.99)
//var wDiff = float64(1.0)
var sDiff = 0.0001


//blockchain index for 200 years
var pindex = make([]int64, 52596006)
var targets = make([]big.Int, 52596006)

var supply = 0.0 //moneysupply
var fees = 0.0

var wHour = 29 //PoW blocks' rate per 1 hour
var shour = 1  // PoS blocks' rate per 1 hour

var maxTgt = "26959535291011309493156476344723991336010898738574164086137773096960"
var Limit = "26959123914871979191645937602428351998384653054607755691171935944704"



func getWdiff() float64 {

	actSpacing := pindex[block - 1] - pindex[block - 2]
	tgtSpacing := 61 * (1 + pindex[block - 1] - pindex[block - 2])
//	tgtSpacing := int64(600 * (1 + 1))

	if tgtSpacing==0 { tgtSpacing = 1 }
	interval := int64(tgtTimeSpan / tgtSpacing)
//	fmt.Println("Interval=", interval)
	bits := new(big.Int)
	bits = &targets[block - 1]
//	fmt.Println("Bits_0=", bits.String())
	bits.Mul(bits, big.NewInt((interval + int64(1)) * tgtSpacing + actSpacing + actSpacing))
	bits.Div(bits, big.NewInt((interval - int64(1)) * tgtSpacing))

	bitsTest := new(big.Int)
	if block > 95 {
		bitsTest.Sub(bits, &targets[block - 60])
//		fmt.Println("BitsTest=", bitsTest.String(), bitsTest.Sign())
		cmp := bitsTest.Cmp(&targets[block - 30])
		if cmp == 1 {
//			bits.Add(&targets[block - 10], bits)
			bits.Div(bits, big.NewInt(2))
//			bits.Mul(bits, big.NewInt(2))
			fmt.Println("B/2 ====", bits.String())
		}
	}
	if bits.Cmp(&targets[0])==1 { bits = &targets[0] }
//	fmt.Println("Bits_3=", bits.String())
	targets[block].Set(bits)

	diff := new(big.Int)
//	if block > 3 {
	diff.Div(&targets[0], bits)
//	diff.Set(&targets[0])
//	} else {
//		return float64(1.0)
//	}
//	fmt.Println("diff=", diff.String())
//	return float64(diff.Int64()) / float64(bits.Int64())
	return float64(diff.Int64())
}

//nth root function
func root(a float64, n int) float64 {
	n1 := n - 1
	n1f, rn := float64(n1), 1/float64(n)
	x, x0 := 1., 0.
	for {
		potx, t2 := 1/x, a
		for b := n1; b > 0; b >>= 1 {
			if b&1 == 1 {
				t2 *= potx
			}
			potx *= potx
		}
		x0, x = x, rn*(n1f*x+t2)
		if math.Abs(x-x0)*1e15 < x {
			break
		}
	}
	return x
}

func main() {
	flag.Parse()
	wReward := 0.0
//	sReward := 0.0
//	suppDelta := 0.0
	supplyPrev := 0.000000001
	targets[0].SetString(maxTgt, 10)
	targets[1].SetString(maxTgt, 10)
	targets[2].SetString(maxTgt, 10)
	targets[3].SetString(Limit, 10)
	targets[4].SetString(Limit, 10)
//	fmt.Println(targets[3].String())
	fl, _ := strconv.ParseInt(flag.Arg(0), 10, 8)

	//years to mine in blocks
	eoTime := year*int(fl) + 2

	pindex[0] = time.Now().Unix()
	pindex[1] = pindex[0] + 120
	pindex[2] = pindex[1] + 120
	pindex[3] = pindex[2] + 120
	pindex[4] = pindex[3] + 120
//	fmt.Println("started at : ", pindex[0])

	rnd := rand.New(rand.NewSource((int64(time.Now().Nanosecond()))))
	for {
		if block < 10000000000 {
			wDiff := getWdiff()
//			fmt.Println("diff=", strconv.FormatFloat(wDiff, 'f', -1, 64))

//			wReward = math.Log(wDiff) - (supply * percent)
//			wReward = maxWreward / root(wDiff, 6)
//			wReward = root(wDiff, 3) + root(wDiff, 6)// + (supply * percent)

//			wReward = root(wDiff, 2) - (supply * percent)
//			wReward = root(wDiff, 2) - (supply * percent) + 3 * root(float64(block), 2)
//			wReward = root(wDiff, 2) + math.Sqrt(float64(1 / block))

//			wReward = math.Sqrt(float64(9999 * block)) / 5000.0
//			wReward =  math.Sqrt(wDiff) - root(float64(block), 2) / 100.0

//			wReward = wDiff / 2.0
			wReward = math.Sqrt(wDiff) + (supply * percent)

//			wReward = (2.0 * math.Sqrt(wDiff) + wDiff / float64(block * block))/2.0


			//			fmt.Println("PoW bounty: ", wReward, "wDiff=", wDiff)
//			if block > 10 {
//				wDiff = (1.005*wDiff + rnd.Float64()*111111.0 + 1.0) / 2
//			}
//			if wDiff > 64000.0 {
//				wDiff = 63999.0
//			}
			block++
			freq := 121//average time between blocks
//			if wDiff > 63300000.0 { freq = 119 }
			if wDiff > 670.0 { freq = 119 }
			after := rnd.Int63n(240) - int64(freq)//power input point ;)

			pindex[block] = pindex[block - 1] + after
//			fmt.Println(block, pindex[block] - pindex[block-1])
		}
		//		if block >= 1000000 { wReward = 0.0 }
		txFees := rnd.Float64() / 1.35
		if txFees > 0.66 {
			txFees = 0.02
		}
//		coinAge := rnd.Int63n(89970) + 30 //pseudorandom  coin_age in days
//		sReward := float64((33*coinAge)/12053) * 0.01

		//		fmt.Println("PoS: ", sReward, "Fees=", txFees)
		//		sRewardAndFees := sReward + txFees

//		block++
		//		fmt.Println("")
		supply = supply + wReward// + sReward
		fees = fees + txFees
		if (block % year) == 0 {
			supplyDelta := (supply / supplyPrev - 1.0) * 100
			fmt.Println("coinsupply= ", strconv.FormatFloat(supply, 'f', -1, 64), " at year #", (block / year))
			fmt.Println("+ from prev. year=", supplyDelta, "%")
//			fmt.Println("tx_fees =", fees)
			fmt.Println("PoW bounty: ", wReward, "Diff=", getWdiff())
//			fmt.Println("PoS: ", sReward, "Fees=", txFees)
			fmt.Println("==========================================================")
			supplyPrev = supply
		}
		if block > eoTime {
			break
		}
	}

	os.Exit(0)
}