2018-02-02 00:36:30 +00:00
|
|
|
from Blockchain import *
|
2018-02-08 20:06:01 +00:00
|
|
|
import copy
|
2018-02-02 00:36:30 +00:00
|
|
|
|
|
|
|
|
class Node(object):
|
|
|
|
|
'''
|
|
|
|
|
Node object. params [identity, blockchain (data), verbosity, difficulty]
|
|
|
|
|
'''
|
|
|
|
|
def __init__(self, params={}):
|
|
|
|
|
try:
|
|
|
|
|
assert len(params)==4
|
|
|
|
|
except AssertionError:
|
|
|
|
|
print("Error, Tried to create malformed node.")
|
|
|
|
|
else:
|
|
|
|
|
self.ident = params["ident"]
|
|
|
|
|
self.data = params["data"]
|
|
|
|
|
self.diff = params["diff"]
|
|
|
|
|
self.verbose = params["verbose"]
|
|
|
|
|
self.edges = {}
|
|
|
|
|
|
|
|
|
|
def updateBlockchain(self, incBlocks, diffUpdateRate=1, mode="Nakamoto", targetRate=1.0/1209600.0):
|
2018-02-08 20:06:01 +00:00
|
|
|
# incBlocks shall be a dictionary of block identities (as keys) and their associated blocks (as values)
|
2018-02-02 00:36:30 +00:00
|
|
|
# to be added to the local data. We assume difficulty scores have been reported honestly for now.
|
|
|
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("\t\t Updating blockchain.")
|
|
|
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("\t\tAdding incoming blocks in order of parentage")
|
|
|
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("\t\tFirst step. incBlocks has " + str(len(incBlocks)) + " entries.")
|
|
|
|
|
tempData = copy.deepcopy(incBlocks)
|
|
|
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("\t\t Now tempData has " + str(len(tempData)) + " entries.")
|
|
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
for key in incBlocks:
|
2018-02-02 00:36:30 +00:00
|
|
|
if key in self.data["blockchain"].blocks:
|
|
|
|
|
del tempData[key]
|
2018-02-08 20:06:01 +00:00
|
|
|
elif incBlocks[key].parent in self.data["blockchain"].blocks or incBlocks[key].parent is None:
|
|
|
|
|
self.data["blockchain"].addBlock(incBlocks[key])
|
|
|
|
|
self.data["blockchain"].whichLeaf()
|
2018-02-02 00:36:30 +00:00
|
|
|
#if len(self.data["blockchain"]) % diffUpdateRate == 0:
|
|
|
|
|
# self.updateDifficulty(mode, targetRate)
|
|
|
|
|
del tempData[key]
|
|
|
|
|
incBlocks = copy.deepcopy(tempData)
|
|
|
|
|
|
|
|
|
|
if self.verbose:
|
2018-02-08 20:06:01 +00:00
|
|
|
print("\t\t Now incBlocks has " + str(len(incBlocks)) + " entries.")
|
2018-02-02 00:36:30 +00:00
|
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("\t\tRemaining steps (while loop)")
|
|
|
|
|
|
|
|
|
|
while len(incBlocks)>0:
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("\t\t Now tempData has " + str(len(tempData.blocks)) + " entries.")
|
|
|
|
|
for key in incBlocks:
|
|
|
|
|
if key in self.data["blockchain"].blocks:
|
|
|
|
|
del tempData[key]
|
2018-02-08 20:06:01 +00:00
|
|
|
elif incBlocks[key].parent in self.data["blockchain"].blocks:
|
|
|
|
|
self.data["blockchain"].addBlock(incBlocks[key])
|
|
|
|
|
self.data["blockchain"].whichLeaf()
|
2018-02-02 00:36:30 +00:00
|
|
|
del tempData[key]
|
|
|
|
|
incBlocks = copy.deepcopy(tempData)
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("\t\t Now incBlocks has " + str(len(incBlocks)) + " entries.")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def updateDifficulty(self, mode="Nakamoto", targetRate=1.0/1209600.0):
|
|
|
|
|
# Compute the difficulty of the next block
|
|
|
|
|
# Note for default, targetRate = two weeks/period, seven days/week, 24 hours/day, 60 minutes/hour, 60 seconds/minute) = 1209600 seconds/period
|
|
|
|
|
if mode=="Nakamoto":
|
|
|
|
|
# Use MLE estimate of poisson process, compare to targetRate, update by multiplying by resulting ratio.
|
2018-02-08 20:06:01 +00:00
|
|
|
if self.verbose:
|
|
|
|
|
print("Beginning update of difficulty with Nakamoto method")
|
2018-02-02 00:36:30 +00:00
|
|
|
count = 2016
|
|
|
|
|
bc = self.data["blockchain"]
|
2018-02-08 20:06:01 +00:00
|
|
|
if self.verbose:
|
|
|
|
|
print("Checking that blockchain is 2016*n blocks long and some mining identity has been set")
|
|
|
|
|
if len(bc.blocks) % 2016 == 0 and len(bc.miningIdents) > 0:
|
|
|
|
|
|
|
|
|
|
ident = random.choice(bc.miningIdents)
|
|
|
|
|
topTime = copy.deepcopy(bc.blocks[ident].discoTimestamp)
|
2018-02-02 00:36:30 +00:00
|
|
|
parent = bc.blocks[ident].parent
|
|
|
|
|
count = count - 1
|
2018-02-08 20:06:01 +00:00
|
|
|
touched = False
|
|
|
|
|
while count > 0 and parent is not None:
|
|
|
|
|
ident = copy.deepcopy(parent)
|
|
|
|
|
parent = bc.blocks[ident].parent
|
|
|
|
|
count = count - 1
|
|
|
|
|
touched = True
|
|
|
|
|
if not touched:
|
|
|
|
|
mleDiscoRate = targetRate
|
|
|
|
|
else:
|
|
|
|
|
botTime = copy.deepcopy(bc.blocks[ident].discoTimestamp)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# Algebra is okay:
|
|
|
|
|
assert topTime != botTime
|
|
|
|
|
|
|
|
|
|
# MLE estimate of arrivals per second:
|
|
|
|
|
mleDiscoRate = float(2015)/float(topTime - botTime)
|
|
|
|
|
|
|
|
|
|
# Rates can't be negative, but this estimate could be (although it's highly unlikely given Bitcoin's standard choices
|
|
|
|
|
# of difficulty update rate, etc.
|
|
|
|
|
mleDiscoRate = abs(mleDiscoRate)
|
|
|
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("MLE disco rate = " + str(mleDiscoRate) + " and targetRate = " + str(targetRate))
|
|
|
|
|
# Rate must be positive... so the MLE for block arrival rate
|
|
|
|
|
# assuming a Poisson process _is not even well-defined_ as
|
|
|
|
|
# an estimate for block arrival rate assuming timestamps are
|
|
|
|
|
# inaccurately reported!
|
|
|
|
|
|
|
|
|
|
# We use it nonetheless.
|
|
|
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("MLE discovery rate = " + str(mleDiscoRate))
|
|
|
|
|
print("Difficulty before adjustment = " + str(self.diff))
|
|
|
|
|
|
|
|
|
|
# Update difficulty multiplicatively
|
|
|
|
|
self.diff = self.diff*mleDiscoRate/targetRate
|
|
|
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("Difficulty after adjustment = ", str(self.diff))
|
2018-02-02 00:36:30 +00:00
|
|
|
|
|
|
|
|
elif mode=="vanSaberhagen":
|
|
|
|
|
# Similar to above, except use 1200 blocks, discard top 120 and bottom 120 after sorting.
|
|
|
|
|
# 4 minute blocks in the original cryptonote, I believe... targetRate = 1.0/
|
|
|
|
|
# 4 minutes/period, 60 seconds/minute ~ 240 seconds/period
|
2018-02-08 20:06:01 +00:00
|
|
|
# assert targetRate==1.0/240.0
|
2018-02-02 00:36:30 +00:00
|
|
|
count = 1200
|
2018-02-08 20:06:01 +00:00
|
|
|
bc = self.data["blockchain"]
|
|
|
|
|
bc.whichLeaf()
|
|
|
|
|
assert self.diff != 0.0
|
|
|
|
|
if len(bc.blocks) > 120:
|
|
|
|
|
assert type(bc.miningIdents)==type([])
|
|
|
|
|
assert len(bc.miningIdents) > 0
|
|
|
|
|
ident = random.choice(bc.miningIdents)
|
|
|
|
|
bl = []
|
|
|
|
|
bl.append(copy.deepcopy(bc.blocks[ident].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[ident].parent
|
|
|
|
|
count = count - 1
|
|
|
|
|
while count > 0 and parent is not None:
|
|
|
|
|
ident = copy.deepcopy(parent)
|
|
|
|
|
bl.append(copy.deepcopy(bc.blocks[ident].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[ident].parent
|
|
|
|
|
count = count-1
|
|
|
|
|
# sort
|
|
|
|
|
bl = sorted(bl)
|
|
|
|
|
assert len(bl)<=1200
|
|
|
|
|
|
|
|
|
|
#print("Sample size = " + str(len(bl)))
|
|
|
|
|
# remove 10 and 90 %-iles
|
|
|
|
|
numOutliers = round(len(bl)/5)//2
|
|
|
|
|
assert numOutliers <= 120
|
|
|
|
|
#print("Number of outliers = " + str(numOutliers))
|
|
|
|
|
if numOutliers > 0:
|
|
|
|
|
bl = bl[numOutliers:-numOutliers]
|
|
|
|
|
#print("New Sample Size = " + str(len(bl)))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# get topTime and botTime
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("bl[0] = " + str(bl[0]) + ",\tbl[-1] = " + str(bl[-1]))
|
|
|
|
|
topTime = bl[-1]
|
|
|
|
|
botTime = bl[0]
|
|
|
|
|
if self.verbose:
|
|
|
|
|
print("list of timestamps = " + str(bl))
|
|
|
|
|
print("topTime = " + str(bl[-1]))
|
|
|
|
|
print("botTime = " + str(bl[0]))
|
|
|
|
|
|
|
|
|
|
# Assert algebra will work
|
|
|
|
|
# 1200 - 2*120 = 1200 - 240 = 960
|
|
|
|
|
assert 0 < len(bl) and len(bl) < 961
|
|
|
|
|
assert topTime - botTime >= 0.0
|
|
|
|
|
|
|
|
|
|
# Sort of the MLE: # blocks/difference in reported times
|
|
|
|
|
# But not the MLE, since the reported times may not be
|
|
|
|
|
# the actual times, the "difference in reported times" !=
|
|
|
|
|
# "ground truth difference in block discoery times" in general
|
|
|
|
|
naiveDiscoRate = (960 - count)/(topTime - botTime)
|
|
|
|
|
|
|
|
|
|
# How much should difficulty change?
|
|
|
|
|
self.diff = self.diff*(naiveDiscoRate/targetRate)
|
|
|
|
|
|
2018-02-02 00:36:30 +00:00
|
|
|
elif mode=="MOM:expModGauss":
|
|
|
|
|
# Similar to "vanSaberhagen" except with 2-minute blocks and
|
|
|
|
|
# we attempt to take into account that "difference in timestamps"
|
|
|
|
|
# can be negative by:
|
|
|
|
|
# 1) insisting that the ordering induced by the blockchain and
|
|
|
|
|
# 2) modeling timestamps as exponentially modified gaussian.
|
|
|
|
|
# If timestamps are T = X + Z where X is exponentially dist-
|
|
|
|
|
# ributed with parameter lambda and Z is some Gaussian
|
|
|
|
|
# noise with average mu and variance sigma2, then we can est-
|
|
|
|
|
# imate sigma2, mu, and lambda:
|
|
|
|
|
# mu ~ mean - stdev*(skewness/2)**(1.0/3.0)
|
|
|
|
|
# sigma2 ~ variance*(1-(skewness/2)**(2.0/3.0))
|
|
|
|
|
# lambda ~ (1.0/(stdev))*(2/skewness)**(1.0/3.0)
|
|
|
|
|
assert targetRate==1.0/120.0
|
|
|
|
|
count = 1200
|
2018-02-08 20:06:01 +00:00
|
|
|
bc = self.data["blockchain"]
|
|
|
|
|
if len(bc.miningIdents) > 0:
|
|
|
|
|
ident = random.choice(bc.miningIdents)
|
|
|
|
|
|
2018-02-02 00:36:30 +00:00
|
|
|
bl = []
|
2018-02-08 20:06:01 +00:00
|
|
|
bl.append(copy.deepcopy(bc.blocks[ident].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[ident].parent
|
2018-02-02 00:36:30 +00:00
|
|
|
count = count - 1
|
2018-02-08 20:06:01 +00:00
|
|
|
while count > 0 and parent is not None:
|
2018-02-02 00:36:30 +00:00
|
|
|
ident = copy.deepcopy(parent)
|
2018-02-08 20:06:01 +00:00
|
|
|
bl.append(copy.deepcopy(bc.blocks[ident].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[ident].parent
|
2018-02-02 00:36:30 +00:00
|
|
|
count = count-1
|
2018-02-08 20:06:01 +00:00
|
|
|
if len(bl) > 120:
|
|
|
|
|
sk = skew(bl)
|
|
|
|
|
va = var(bl)
|
|
|
|
|
stdv = sqrt(va)
|
|
|
|
|
lam = (1.0/stdv)*(2.0/sk)**(1.0/3.0)
|
|
|
|
|
else:
|
|
|
|
|
lam = targetRate # we will not change difficulty unless we have at least 120 blocks of data (arbitrarily selected)
|
2018-02-02 00:36:30 +00:00
|
|
|
self.diff = self.diff*(lam/targetRate)
|
|
|
|
|
else:
|
|
|
|
|
print("Error, invalid difficulty mode entered.")
|
|
|
|
|
|
|
|
|
|
def propagate(self, t, blockIdent):
|
|
|
|
|
for edgeIdent in self.edges:
|
|
|
|
|
e = self.edges[edgeIdent]
|
|
|
|
|
l = e.data["length"]
|
|
|
|
|
toa = t + l
|
|
|
|
|
mIdent = e.getNeighbor(self.ident)
|
|
|
|
|
m = e.nodes[mIdent]
|
|
|
|
|
bc = m.data["blockchain"]
|
|
|
|
|
if blockIdent not in bc.blocks:
|
|
|
|
|
pB = e.data["pendingBlocks"]
|
|
|
|
|
pendingIdent = newIdent(len(pB))
|
|
|
|
|
mybc = self.data["blockchain"]
|
|
|
|
|
pendingDat = {"timeOfArrival":toa, "destIdent":mIdent, "block":mybc.blocks[blockIdent]}
|
|
|
|
|
pB.update({pendingIdent:pendingDat})
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class Test_Node(unittest.TestCase):
|
2018-02-08 20:06:01 +00:00
|
|
|
# TODO test each method separately
|
|
|
|
|
'''def test_nakamoto(self):
|
|
|
|
|
print("Beginning test of Nakamoto difficulty adjustment")
|
|
|
|
|
print("Setting initial values")
|
|
|
|
|
target = 100.0 # rate = blocks/s
|
|
|
|
|
verbose = False
|
|
|
|
|
deltaT = 1.0/target # forced wait time
|
|
|
|
|
arrivalList = []
|
|
|
|
|
mode="Nakamoto"
|
|
|
|
|
|
|
|
|
|
print("Generating node")
|
2018-02-02 00:36:30 +00:00
|
|
|
nellyIdent = newIdent(0)
|
2018-02-08 20:06:01 +00:00
|
|
|
offset = random.random()
|
|
|
|
|
intensity = random.random()
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
print("Generating initial blockchain")
|
|
|
|
|
# Create a new initial blockchain object
|
|
|
|
|
bill = Blockchain([], verbosity=verbose)
|
2018-02-02 00:36:30 +00:00
|
|
|
name = newIdent(0)
|
|
|
|
|
t = time.time()
|
2018-02-08 20:06:01 +00:00
|
|
|
t += offset
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
2018-02-02 00:36:30 +00:00
|
|
|
diff = 1.0
|
2018-02-08 20:06:01 +00:00
|
|
|
oldDiff = copy.deepcopy(diff)
|
2018-02-02 00:36:30 +00:00
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":None, "diff":diff}
|
|
|
|
|
genesis = Block(params)
|
2018-02-08 20:06:01 +00:00
|
|
|
print("Adding block")
|
2018-02-02 00:36:30 +00:00
|
|
|
bill.addBlock(genesis)
|
2018-02-08 20:06:01 +00:00
|
|
|
bill.whichLeaf()
|
|
|
|
|
|
|
|
|
|
# Check that it consists only of the genesis block
|
|
|
|
|
self.assertTrue(len(bill.blocks)==1)
|
|
|
|
|
self.assertTrue(genesis.ident in bill.blocks)
|
|
|
|
|
self.assertTrue(genesis.parent is None)
|
|
|
|
|
|
|
|
|
|
print("Finish creating node")
|
|
|
|
|
# Create node with this blockchain.
|
|
|
|
|
nodeData = {"blockchain":bill, "intensity":intensity, "offset":offset}
|
|
|
|
|
params = {"ident":nellyIdent, "data":nodeData, "diff":diff, "verbose":verbose}
|
|
|
|
|
nelly = Node(params)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# Check node creation worked
|
|
|
|
|
self.assertEqual(nelly.ident, nellyIdent)
|
|
|
|
|
self.assertEqual(nelly.data["blockchain"], bill)
|
|
|
|
|
self.assertEqual(nelly.diff, diff)
|
|
|
|
|
self.assertEqual(nelly.data["intensity"], intensity)
|
|
|
|
|
self.assertEqual(nelly.data["offset"], offset)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# Sleep and add a block on top of genesis
|
|
|
|
|
if verbose:
|
|
|
|
|
print("sleeping")
|
|
|
|
|
time.sleep(deltaT)
|
|
|
|
|
|
|
|
|
|
print("Giving genesis block a child")
|
2018-02-02 00:36:30 +00:00
|
|
|
name = newIdent(1)
|
|
|
|
|
t = time.time()
|
2018-02-08 20:06:01 +00:00
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
diff = oldDiff
|
2018-02-02 00:36:30 +00:00
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":genesis.ident, "diff":diff}
|
|
|
|
|
blockA = Block(params)
|
2018-02-08 20:06:01 +00:00
|
|
|
nelly.updateBlockchain({blockA.ident:blockA})
|
|
|
|
|
oldIdent = blockA.ident
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),2)
|
|
|
|
|
self.assertTrue(blockA.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
self.assertTrue(genesis.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
self.assertEqual(genesis.ident, nelly.data["blockchain"].blocks[blockA.ident].parent)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
print("Updating difficulty")
|
|
|
|
|
# Update the difficulty score
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target) # With only two blocks, nothing should change.
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# Print regardless of verbosity:
|
|
|
|
|
print("Now generating first difficulty adjustment period.")
|
|
|
|
|
|
|
|
|
|
# Now we are going to fast forward to right before the first difficulty adjustment.
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
while(N < 2015):
|
|
|
|
|
if N % 100 == 0:
|
|
|
|
|
print("\tN=" + str(N))
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
diff = nelly.diff
|
|
|
|
|
oldDiff = diff
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":oldIdent, "diff":diff}
|
|
|
|
|
oldIdent = copy.deepcopy(name)
|
|
|
|
|
block = Block(params)
|
|
|
|
|
nelly.updateBlockchain({block.ident:block})
|
|
|
|
|
|
|
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),N+1)
|
|
|
|
|
self.assertTrue(block.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update the difficulty score
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target) # With N < 2016, nothing should change.
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
time.sleep(deltaT)
|
|
|
|
|
|
|
|
|
|
name = newIdent(N)
|
2018-02-02 00:36:30 +00:00
|
|
|
t = time.time()
|
2018-02-08 20:06:01 +00:00
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
diff = oldDiff
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":oldIdent, "diff":diff}
|
|
|
|
|
block = Block(params)
|
|
|
|
|
nelly.updateBlockchain({block.ident:block})
|
|
|
|
|
|
|
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),N+1)
|
|
|
|
|
self.assertTrue(block.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update the difficulty score
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target) # With N < 2016, nothing should change.
|
|
|
|
|
# Note: 2016 blocks is 2015 block inter-arrival times.
|
|
|
|
|
expRatioNumerator = float(2015)/(arrivalList[-1] - arrivalList[-2016])
|
|
|
|
|
expRatio = expRatioNumerator/target
|
|
|
|
|
expDiff = oldDiff*expRatio
|
|
|
|
|
self.assertEqual(nelly.diff, expDiff)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# The following should fail, because our sample size is incorrect.
|
|
|
|
|
expRatioNumerator = float(2016)/(arrivalList[-1] - arrivalList[-2016])
|
|
|
|
|
expRatio = expRatioNumerator/target
|
|
|
|
|
expDiff = oldDiff*expRatio
|
|
|
|
|
self.assertFalse(nelly.diff - expDiff == 0.0)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
|
|
|
|
|
# Print regardless of verbosity:
|
|
|
|
|
print("Now generating second difficulty adjustment period.")
|
|
|
|
|
|
|
|
|
|
# Now we are going to fast forward to right before the next difficulty adjustment.
|
|
|
|
|
# This time, though, we are going to re-set the block inter-arrival time deltaT
|
|
|
|
|
# to half. This should drive difficulty up.
|
|
|
|
|
lastDifficultyScore = copy.deepcopy(nelly.diff)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
while(N < 4031):
|
|
|
|
|
if N % 100 == 0:
|
|
|
|
|
print("\tN=" + str(N))
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
diff = nelly.diff
|
|
|
|
|
oldDiff = diff
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":oldIdent, "diff":diff}
|
|
|
|
|
oldIdent = copy.deepcopy(name)
|
|
|
|
|
block = Block(params)
|
|
|
|
|
nelly.updateBlockchain({block.ident:block})
|
|
|
|
|
|
|
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),N+1)
|
|
|
|
|
self.assertTrue(block.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update the difficulty score
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target) # With N < 2016, nothing should change.
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
time.sleep(0.01*deltaT)
|
|
|
|
|
|
|
|
|
|
# Now if we add a single new block, we should trigger difficulty adjustment.
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
diff = oldDiff
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":oldIdent, "diff":diff}
|
|
|
|
|
block = Block(params)
|
|
|
|
|
nelly.updateBlockchain({block.ident:block})
|
|
|
|
|
|
|
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),N+1)
|
|
|
|
|
self.assertTrue(block.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update the difficulty score.
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target)
|
|
|
|
|
expRatioNumerator = float(2015)/(arrivalList[-1] - arrivalList[-2016])
|
|
|
|
|
expRatio = expRatioNumerator/target
|
|
|
|
|
expDiff = oldDiff*expRatio
|
|
|
|
|
print("expRatio = " + str(expRatio) + ", lastDifficultyScore = " + str(lastDifficultyScore) + ", new difficulty = " + str(nelly.diff))
|
|
|
|
|
self.assertEqual(nelly.diff, expDiff)
|
|
|
|
|
'''
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_vs(self):
|
|
|
|
|
print("Beginning test of vanSaberhagen difficulty adjustment.")
|
|
|
|
|
print("Setting initial values")
|
|
|
|
|
target = 10.0 # 1.0/240.0 # rate = blocks/s
|
|
|
|
|
verbose = False
|
|
|
|
|
deltaT = 1.0/target # forced wait time
|
|
|
|
|
arrivalList = []
|
|
|
|
|
mode="vanSaberhagen"
|
|
|
|
|
|
|
|
|
|
print("Instantiating new node")
|
|
|
|
|
nellyIdent = newIdent(0)
|
|
|
|
|
offset = random.random()
|
|
|
|
|
intensity = random.random()
|
|
|
|
|
|
|
|
|
|
print("Creating new blockchain for new node")
|
|
|
|
|
# Create a new initial blockchain object
|
|
|
|
|
bill = Blockchain([], verbosity=verbose)
|
|
|
|
|
name = newIdent(0)
|
2018-02-02 00:36:30 +00:00
|
|
|
t = time.time()
|
2018-02-08 20:06:01 +00:00
|
|
|
t += offset
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
diff = 1.0
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":None, "diff":diff}
|
|
|
|
|
genesis = Block(params)
|
|
|
|
|
print("Adding genesis block")
|
|
|
|
|
bill.addBlock(genesis)
|
|
|
|
|
bill.whichLeaf()
|
|
|
|
|
|
|
|
|
|
# Check that it consists only of the genesis block
|
|
|
|
|
self.assertTrue(len(bill.blocks)==1)
|
|
|
|
|
self.assertTrue(genesis.ident in bill.blocks)
|
|
|
|
|
self.assertTrue(genesis.parent is None)
|
|
|
|
|
self.assertTrue(genesis.ident in bill.leaves)
|
|
|
|
|
|
|
|
|
|
print("Making node")
|
|
|
|
|
# Create node with this blockchain.
|
|
|
|
|
nodeData = {"blockchain":bill, "intensity":intensity, "offset":offset}
|
|
|
|
|
params = {"ident":nellyIdent, "data":nodeData, "diff":diff, "verbose":verbose}
|
|
|
|
|
nelly = Node(params)
|
|
|
|
|
|
|
|
|
|
# Check node creation worked
|
|
|
|
|
self.assertEqual(nelly.ident, nellyIdent)
|
|
|
|
|
self.assertEqual(nelly.data["blockchain"], bill)
|
|
|
|
|
self.assertEqual(nelly.diff, diff)
|
|
|
|
|
self.assertEqual(nelly.data["intensity"], intensity)
|
|
|
|
|
self.assertEqual(nelly.data["offset"], offset)
|
|
|
|
|
|
|
|
|
|
# Sleep and add a block on top of genesis
|
|
|
|
|
if verbose:
|
|
|
|
|
print("sleeping")
|
|
|
|
|
time.sleep(deltaT)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
print("Give genesis a child")
|
|
|
|
|
name = newIdent(1)
|
2018-02-02 00:36:30 +00:00
|
|
|
t = time.time()
|
2018-02-08 20:06:01 +00:00
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
oldDiff = copy.deepcopy(diff)
|
|
|
|
|
diff = copy.deepcopy(nelly.diff)
|
|
|
|
|
assert diff != 0.0
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":genesis.ident, "diff":diff}
|
|
|
|
|
blockA = Block(params)
|
|
|
|
|
nelly.updateBlockchain({blockA.ident:blockA})
|
|
|
|
|
oldIdent = blockA.ident
|
|
|
|
|
|
|
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),2)
|
|
|
|
|
self.assertTrue(blockA.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
self.assertTrue(genesis.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
self.assertEqual(genesis.ident, nelly.data["blockchain"].blocks[blockA.ident].parent)
|
|
|
|
|
|
|
|
|
|
# Update the difficulty score
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target) # With only two blocks, nothing should change.
|
|
|
|
|
assert nelly.diff != 0.0
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff)
|
|
|
|
|
self.assertFalse(nelly.diff == -0.0)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# Print regardless of verbosity:
|
|
|
|
|
print("Now generating fulls sample size.")
|
|
|
|
|
|
|
|
|
|
# Now we are going to fast forward to a "full sample size" period of time.
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
while(N < 1200):
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
if N % 100 == 0:
|
|
|
|
|
print("\tNow adding block N=" + str(N))
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
oldDiff = copy.deepcopy(diff)
|
|
|
|
|
diff = copy.deepcopy(nelly.diff)
|
|
|
|
|
assert diff != 0.0
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":oldIdent, "diff":diff}
|
|
|
|
|
oldIdent = copy.deepcopy(name)
|
|
|
|
|
block = Block(params)
|
|
|
|
|
nelly.updateBlockchain({block.ident:block})
|
|
|
|
|
|
|
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),N+1)
|
|
|
|
|
self.assertTrue(block.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update the difficulty score
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target) # With N < 100, nothing should change.
|
|
|
|
|
if N < 100:
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
time.sleep(0.5*deltaT)
|
|
|
|
|
|
|
|
|
|
print("Adding one more block")
|
|
|
|
|
name = newIdent(N)
|
2018-02-02 00:36:30 +00:00
|
|
|
t = time.time()
|
2018-02-08 20:06:01 +00:00
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
oldDiff = diff
|
|
|
|
|
diff = nelly.diff
|
|
|
|
|
assert diff != 0.0
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":oldIdent, "diff":nelly.diff}
|
|
|
|
|
block = Block(params)
|
|
|
|
|
nelly.updateBlockchain({block.ident:block})
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),N+1)
|
|
|
|
|
self.assertTrue(block.ident in nelly.data["blockchain"].blocks)
|
2018-02-02 00:36:30 +00:00
|
|
|
|
2018-02-08 20:06:01 +00:00
|
|
|
# Update the difficulty score
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target) # With N < 2016, nothing should change.
|
|
|
|
|
# Note: 2016 blocks is 2015 block inter-arrival times.
|
|
|
|
|
print(str(arrivalList[-120]) + ", " + str(arrivalList[-1080]) + ", " + str(arrivalList[-120]-arrivalList[-1080]) + ", " + str(float(959)/(arrivalList[-120]-arrivalList[-1080]))+ ", " + str(float(float(959)/(arrivalList[-120]-arrivalList[-1080]))/float(target)))
|
|
|
|
|
expRatioNumerator = float(959)/(arrivalList[-120] - arrivalList[-1080])
|
|
|
|
|
expRatio = expRatioNumerator/target
|
|
|
|
|
print(expRatio)
|
|
|
|
|
expDiff = oldDiff*expRatio
|
|
|
|
|
print(expDiff)
|
|
|
|
|
print("expDiff = " + str(expDiff) + " and nelly.diff = " + str(nelly.diff))
|
|
|
|
|
self.assertEqual(nelly.diff, expDiff)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Print regardless of verbosity:
|
|
|
|
|
print("Now fast forwarding past the tail end of the last period..")
|
|
|
|
|
# Now we are going to fast forward to right before the next difficulty adjustment.
|
|
|
|
|
# This time, though, we are going to re-set the block inter-arrival time deltaT
|
|
|
|
|
# to half. This should drive difficulty up.
|
|
|
|
|
lastDifficultyScore = copy.deepcopy(nelly.diff)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
while(N < 1700):
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
diff = nelly.diff
|
|
|
|
|
oldDiff = diff
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":oldIdent, "diff":diff}
|
|
|
|
|
oldIdent = copy.deepcopy(name)
|
|
|
|
|
block = Block(params)
|
|
|
|
|
nelly.updateBlockchain({block.ident:block})
|
|
|
|
|
|
|
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),N+1)
|
|
|
|
|
self.assertTrue(block.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update the difficulty score
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target) # With N < 2016, nothing should change.
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
time.sleep(0.01*deltaT)
|
|
|
|
|
|
|
|
|
|
# Now if we add a single new block, we should trigger difficulty adjustment.
|
|
|
|
|
name = newIdent(N)
|
2018-02-02 00:36:30 +00:00
|
|
|
t = time.time()
|
2018-02-08 20:06:01 +00:00
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
arrivalList.append(t)
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
diff = oldDiff
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":oldIdent, "diff":diff}
|
|
|
|
|
block = Block(params)
|
|
|
|
|
nelly.updateBlockchain({block.ident:block})
|
|
|
|
|
|
|
|
|
|
# Check this worked
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks),N+1)
|
|
|
|
|
self.assertTrue(block.ident in nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update the difficulty score.
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = target)
|
|
|
|
|
expRatioNumerator = float(959)/(arrivalList[-120] - arrivalList[-1080])
|
|
|
|
|
expRatio = expRatioNumerator/target
|
|
|
|
|
expDiff = oldDiff*expRatio
|
|
|
|
|
print("expRatio = " + str(expRatio) + ", lastDifficultyScore = " + str(lastDifficultyScore) + ", new difficulty = " + str(nelly.diff))
|
|
|
|
|
self.assertEqual(nelly.diff, expDiff)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_modexp(self):
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
'''# Check this worked
|
|
|
|
|
if mode == "Nakamoto":
|
|
|
|
|
# In this case we take simple MLE estimate
|
|
|
|
|
ratio = 1.0/abs(t1-t)
|
|
|
|
|
print("Nakamoto mle = " + str(ratio))
|
|
|
|
|
ratio = ratio/target
|
|
|
|
|
print("Normalized = " + str(ratio))
|
|
|
|
|
print("New diff = " + str(ratio*oldDiff))
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
elif mode == "vanSaberhagen":
|
|
|
|
|
# In this case, with only 2 blocks, we just use simple MLE again
|
|
|
|
|
ratio = 1.0/abs(t1-t)
|
|
|
|
|
ratio = ratio/target
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
elif mode == "MOM:expModGauss":
|
|
|
|
|
self.assertEqual(nelly.diff, 1.0)
|
|
|
|
|
# With at least 120 blocks of data...
|
|
|
|
|
#sk = skew(bl)
|
|
|
|
|
#va = var(bl)
|
|
|
|
|
#stdv = sqrt(va)
|
|
|
|
|
#lam = (1.0/stdv)*(2.0/sk)**(1.0/3.0)
|
|
|
|
|
#self.diff = self.diff*(lam/targetRate)
|
|
|
|
|
# Otherwise, set to 1.0
|
|
|
|
|
else:
|
|
|
|
|
print("what world are you living in?")
|
|
|
|
|
|
|
|
|
|
if verbose:
|
|
|
|
|
print("sleeping 1 seconds")
|
|
|
|
|
time.sleep(deltaT/5.0)
|
|
|
|
|
|
|
|
|
|
listOfTimes = [copy.deepcopy(t), copy.deepcopy(t1)]
|
|
|
|
|
listOfBlocks = []
|
|
|
|
|
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
lastIdent = blockA.ident
|
|
|
|
|
|
|
|
|
|
bail = False
|
|
|
|
|
while N < 10 and not bail:
|
|
|
|
|
# Generate new block
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
oldDiff = copy.deepcopy(nelly.diff)
|
|
|
|
|
print("Current difficulty = ", oldDiff)
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":lastIdent, "diff":oldDiff}
|
|
|
|
|
newBlock = Block(params)
|
|
|
|
|
|
|
|
|
|
# Append new block to running list along with creation time
|
|
|
|
|
listOfBlocks.append(newBlock)
|
|
|
|
|
listOfTimes.append(copy.deepcopy(t))
|
|
|
|
|
|
|
|
|
|
# Update nelly's blockchain with newBlock
|
|
|
|
|
nelly.updateBlockchain({newBlock.ident:newBlock})
|
|
|
|
|
lastIdent = name
|
|
|
|
|
|
|
|
|
|
# Quick check that this worked:
|
|
|
|
|
self.assertTrue(name in nelly.data["blockchain"].blocks)
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks), N+1)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update difficulty
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = 100.0)
|
|
|
|
|
|
|
|
|
|
# Quick check that this worked:
|
|
|
|
|
if mode == "Nakamoto":
|
|
|
|
|
# In this case we take use top block and genesis block
|
|
|
|
|
ratio = float(len(nelly.data["blockchain"].blocks) - 1)/(listOfTimes[-1] - listOfTimes[0])
|
|
|
|
|
ratio = ratio / target
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
print("Hoped for difficulty = " + str(oldDiff*ratio) + ", and computed = " + str(nelly.diff))
|
|
|
|
|
elif mode == "vanSaberhagen":
|
|
|
|
|
# This case coincides with nakamoto until block 10
|
|
|
|
|
ratio = float( len(nelly.data["blockchain"].blocks) - 1)/(listOfTimes[-1] - listOfTimes[0])
|
|
|
|
|
ratio = ratio / target
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
elif mode == "MOM:expModGauss":
|
|
|
|
|
self.assertEqual(nelly.diff, 1.0)
|
|
|
|
|
# With at least 120 blocks of data...
|
|
|
|
|
#sk = skew(bl)
|
|
|
|
|
#va = var(bl)
|
|
|
|
|
#stdv = sqrt(va)
|
|
|
|
|
#lam = (1.0/stdv)*(2.0/sk)**(1.0/3.0)
|
|
|
|
|
#self.diff = self.diff*(lam/targetRate)
|
|
|
|
|
# Otherwise, set to 1.0
|
|
|
|
|
else:
|
|
|
|
|
print("what world are you living in?")
|
|
|
|
|
|
|
|
|
|
# Sleep a random time
|
|
|
|
|
print("Sleeping a random sub-second, working on block " + str(N))
|
|
|
|
|
deltaT = deltaT*ratio
|
|
|
|
|
time.sleep(deltaT/5.0)
|
|
|
|
|
|
|
|
|
|
while N < 120 and not bail:
|
|
|
|
|
# Generate new block
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
oldDiff = copy.deepcopy(nelly.diff)
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":lastIdent, "diff":oldDiff}
|
|
|
|
|
newBlock = Block(params)
|
|
|
|
|
|
|
|
|
|
# Append new block to running list along with creation time
|
|
|
|
|
listOfBlocks.append(newBlock)
|
|
|
|
|
listOfTimes.append(copy.deepcopy(t))
|
|
|
|
|
|
|
|
|
|
# Update nelly's blockchain with newBlock
|
|
|
|
|
nelly.updateBlockchain({newBlock.ident:newBlock})
|
|
|
|
|
lastIdent = name
|
|
|
|
|
|
|
|
|
|
# Quick check that this worked:
|
|
|
|
|
self.assertTrue(name in nelly.data["blockchain"].blocks)
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks), N+1)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update difficulty
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = 100.0)
|
|
|
|
|
|
|
|
|
|
# Quick check that this worked:
|
|
|
|
|
if mode == "Nakamoto":
|
|
|
|
|
# In this case we take use top block and genesis block
|
|
|
|
|
ratio = float(len(nelly.data["blockchain"].blocks)-1)/(listOfTimes[-1] - listOfTimes[0])
|
|
|
|
|
ratio = ratio / target
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff*ratio)
|
|
|
|
|
print("Hoped for difficulty = " + str(oldDiff*ratio) + ", and computed = " + str(nelly.diff))
|
|
|
|
|
elif mode == "vanSaberhagen":
|
|
|
|
|
# This case no longer coincides with Nakamoto...
|
|
|
|
|
numOutliers = len(nelly.data["blockchain"].blocks)//10
|
|
|
|
|
numOutliers = min(numOutliers, 120)
|
|
|
|
|
ratio = float(len(nelly.data["blockchain"].blocks) - 2*numOutliers - 1)/(listOfTimes[-numOutliers] - listOfTimes[numOutliers])
|
|
|
|
|
ratio = ratio / target
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff*ratio)
|
|
|
|
|
elif mode == "MOM:expModGauss":
|
|
|
|
|
# With at least 120 blocks of data...
|
|
|
|
|
count = 1200
|
|
|
|
|
bl = []
|
|
|
|
|
bl.append(copy.deepcopy(bc.blocks[lastIdent].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[lastIdent].parent
|
|
|
|
|
count = count - 1
|
|
|
|
|
while count > 0 and parent is not None:
|
|
|
|
|
ident = copy.deepcopy(parent)
|
|
|
|
|
bl.append(copy.deepcopy(bc.blocks[ident].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[ident].parent
|
|
|
|
|
count = count-1
|
|
|
|
|
if len(bl) > 120:
|
|
|
|
|
sk = skew(bl)
|
|
|
|
|
va = var(bl)
|
|
|
|
|
stdv = sqrt(va)
|
|
|
|
|
lam = (1.0/stdv)*(2.0/sk)**(1.0/3.0)
|
|
|
|
|
else:
|
|
|
|
|
lam = target
|
|
|
|
|
ratio = lam/target
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff*ratio)
|
|
|
|
|
|
|
|
|
|
else:
|
|
|
|
|
print("what world are you living in?")
|
|
|
|
|
|
|
|
|
|
# Sleep a random time
|
|
|
|
|
print("Sleeping a random sub-second, working on block " + str(N))
|
|
|
|
|
deltaT = deltaT*ratio
|
|
|
|
|
time.sleep(deltaT/5.0)
|
|
|
|
|
|
|
|
|
|
while N < 2400 and not bail:
|
|
|
|
|
# Generate new block
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
oldDiff = copy.deepcopy(nelly.diff)
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":lastIdent, "diff":oldDiff}
|
|
|
|
|
newBlock = Block(params)
|
|
|
|
|
|
|
|
|
|
# Append new block to running list along with creation time
|
|
|
|
|
listOfBlocks.append(newBlock)
|
|
|
|
|
listOfTimes.append(copy.deepcopy(t))
|
|
|
|
|
|
|
|
|
|
# Update nelly's blockchain with newBlock
|
|
|
|
|
nelly.updateBlockchain({newBlock.ident:newBlock})
|
|
|
|
|
lastIdent = name
|
|
|
|
|
|
|
|
|
|
# Quick check that this worked:
|
|
|
|
|
self.assertTrue(name in nelly.data["blockchain"].blocks)
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks), N+1)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update difficulty
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = 100.0)
|
|
|
|
|
|
|
|
|
|
# Quick check that this worked:
|
|
|
|
|
if mode == "Nakamoto":
|
|
|
|
|
# In this case we take use top block and genesis block
|
|
|
|
|
ratio = float(len(nelly.data["blockchain"].blocks)-1)/(listOfTimes[-1] - listOfTimes[0])
|
|
|
|
|
ratio = ratio / target
|
|
|
|
|
self.assertEqual(nelly.diff, oldDiff*ratio)
|
|
|
|
|
print("Hoped for difficulty = " + str(oldDiff*ratio) + ", and computed = " + str(nelly.diff))
|
|
|
|
|
elif mode == "vanSaberhagen":
|
|
|
|
|
# This case no longer coincides with Nakamoto...
|
|
|
|
|
numOutliers = len(nelly.data["blockchain"].blocks)//10
|
|
|
|
|
numOutliers = min(numOutliers, 120)
|
|
|
|
|
ratio = float(len(nelly.data["blockchain"].blocks) - 2*numOutliers - 1)/(listOfTimes[-numOutliers] - listOfTimes[numOutliers])
|
|
|
|
|
ratio = ratio / target
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
elif mode == "MOM:expModGauss":
|
|
|
|
|
# With at least 120 blocks of data...
|
|
|
|
|
count = 1200
|
|
|
|
|
bl = []
|
|
|
|
|
bl.append(copy.deepcopy(bc.blocks[lastIdent].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[lastIdent].parent
|
|
|
|
|
count = count - 1
|
|
|
|
|
while count > 0 and parent is not None:
|
|
|
|
|
ident = copy.deepcopy(parent)
|
|
|
|
|
bl.append(copy.deepcopy(bc.blocks[ident].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[ident].parent
|
|
|
|
|
count = count-1
|
|
|
|
|
if len(bl) > 120:
|
|
|
|
|
sk = skew(bl)
|
|
|
|
|
va = var(bl)
|
|
|
|
|
stdv = sqrt(va)
|
|
|
|
|
lam = (1.0/stdv)*(2.0/sk)**(1.0/3.0)
|
|
|
|
|
else:
|
|
|
|
|
lam = targetRate
|
|
|
|
|
ratio = lam/targetRate
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
|
|
|
|
|
else:
|
|
|
|
|
print("what world are you living in?")
|
|
|
|
|
|
|
|
|
|
# Sleep a random time
|
|
|
|
|
print("Sleeping a random sub-second, working on block " + str(N))
|
|
|
|
|
deltaT = deltaT*ratio
|
|
|
|
|
time.sleep(deltaT/5.0)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
while N < 3600 and not bail:
|
|
|
|
|
# Generate new block
|
|
|
|
|
name = newIdent(N)
|
|
|
|
|
t = time.time()
|
|
|
|
|
t += nelly.data["offset"]
|
|
|
|
|
s = t+random.random()
|
|
|
|
|
oldDiff = nelly.diff
|
|
|
|
|
params = {"ident":name, "disco":t, "arriv":s, "parent":lastIdent, "diff":oldDiff}
|
|
|
|
|
newBlock = Block(params)
|
|
|
|
|
|
|
|
|
|
# Append new block to running list along with creation time
|
|
|
|
|
listOfBlocks.append(newBlock)
|
|
|
|
|
listOfTimes.append(copy.deepcopy(t))
|
|
|
|
|
|
|
|
|
|
# Update nelly's blockchain with newBlock
|
|
|
|
|
nelly.updateBlockchain({newBlock.ident:newBlock})
|
|
|
|
|
lastIdent = name
|
|
|
|
|
|
|
|
|
|
# Quick check that this worked:
|
|
|
|
|
self.assertTrue(name in nelly.data["blockchain"].blocks)
|
|
|
|
|
self.assertEqual(len(nelly.data["blockchain"].blocks), N+1)
|
|
|
|
|
N = len(nelly.data["blockchain"].blocks)
|
|
|
|
|
|
|
|
|
|
# Update difficulty
|
|
|
|
|
nelly.updateDifficulty(mode, targetRate = 100.0)
|
|
|
|
|
|
|
|
|
|
# Quick check that this worked:
|
|
|
|
|
if mode == "Nakamoto":
|
|
|
|
|
# In this case we take use top block and genesis block
|
|
|
|
|
ratio = float(2400)/(listOfTimes[-1] - listOfTimes[-2400])
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
elif mode == "vanSaberhagen":
|
|
|
|
|
# This case no longer coincides with Nakamoto...
|
|
|
|
|
numOutliers = len(nelly.data["blockchain"].blocks)//10
|
|
|
|
|
numOutliers = min(numOutliers, 120)
|
|
|
|
|
ratio = float(len(nelly.data["blockchain"].blocks) - 2*numOutliers)/(listOfTimes[-numOutliers] - listOfTimes[numOutliers])
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
elif mode == "MOM:expModGauss":
|
|
|
|
|
# With at least 120 blocks of data...
|
|
|
|
|
count = 1200
|
|
|
|
|
bl = []
|
|
|
|
|
bl.append(copy.deepcopy(bc.blocks[lastIdent].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[lastIdent].parent
|
|
|
|
|
count = count - 1
|
|
|
|
|
while count > 0 and parent is not None:
|
|
|
|
|
ident = copy.deepcopy(parent)
|
|
|
|
|
bl.append(copy.deepcopy(bc.blocks[ident].discoTimestamp))
|
|
|
|
|
parent = bc.blocks[ident].parent
|
|
|
|
|
count = count-1
|
|
|
|
|
if len(bl) > 120:
|
|
|
|
|
sk = skew(bl)
|
|
|
|
|
va = var(bl)
|
|
|
|
|
stdv = sqrt(va)
|
|
|
|
|
lam = (1.0/stdv)*(2.0/sk)**(1.0/3.0)
|
|
|
|
|
else:
|
|
|
|
|
lam = targetRate
|
|
|
|
|
ratio = lam/targetRate
|
|
|
|
|
self.assertEqual(nelly.diff, ratio*oldDiff)
|
|
|
|
|
|
|
|
|
|
else:
|
|
|
|
|
print("what world are you living in?")
|
|
|
|
|
|
|
|
|
|
# Sleep a random time
|
|
|
|
|
print("Sleeping a random sub-second, working on block " + str(N))
|
|
|
|
|
deltaT = deltaT*ratio
|
|
|
|
|
time.sleep(deltaT/5.0)'''
|
2018-02-02 00:36:30 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
suite = unittest.TestLoader().loadTestsFromTestCase(Test_Node)
|
|
|
|
|
unittest.TextTestRunner(verbosity=1).run(suite)
|
|
|
|
|
|
