[research/lotterysim] fix constant stake invariant

script/research/lotterysim/core/constants.py

@@ -35,13 +35,13 @@ VESTING_PERIOD = ONE_MONTH
 # stakeholder assumes  APR target
 TARGET_APR = Num(0.12)
 # primary controller assumes accuracy target
-PRIMARY_REWARD_TARGET = 0.35 # staked ratio
+PRIMARY_REWARD_TARGET = 0.33 # staked ratio
 # secondary controller assumes certain frequency of leaders per slot
 SECONDARY_LEAD_TARGET = 1 #number of lead per slot
 # maximum transaction size
-MAX_BLOCK_SIZE = 100
+MAX_BLOCK_SIZE = 1000
 # maximum transaction computational cost
-MAX_BLOCK_CC = 10
+MAX_BLOCK_CC = 100
 # fee controller computational capacity target
 FEE_TARGET = MAX_BLOCK_CC
 # max fee base value
@@ -51,11 +51,11 @@ FEE_MIN = 0.00001
 # negligible value added to denominator to avoid invalid division by zero
 EPSILON = 1
 # window of accuracy calculation
-ACC_WINDOW = int(EPOCH_LENGTH)
+ACC_WINDOW = int(EPOCH_LENGTH)*10
 # headstart airdrop period
 HEADSTART_AIRDROP = 0
 # threshold of randomly slashing stakeholder
-SLASHING_RATIO = 0.0001
+SLASHING_RATIO = 0.001
 # number of nodes
 NODES = 1000
 # headstart value

script/research/lotterysim/core/darkie.py

@@ -68,7 +68,9 @@ class Darkie():
     update stake with vesting return every scheduled vesting period
     """
     def update_vesting(self):
-        self.stake += self.vesting_differential()
+        diff = self.vesting_differential()
+        self.stake += diff
+        return diff
 
     """
     @returns: current epoch vesting

script/research/lotterysim/core/lottery.py

@@ -62,7 +62,8 @@ class DarkfiTable:
             Ts = []
             for i in range(len(self.darkies)):
                 self.darkies[i].set_sigma_feedback(self.Sigma, self.winners[-1], f, slot, hp)
-                self.darkies[i].update_vesting()
+                diff = self.darkies[i].update_vesting()
+                self.Sigma += diff
                 y, T = self.darkies[i].run(hp)
                 Ys+=[y]
                 Ts+=[T]
@@ -78,7 +79,7 @@ class DarkfiTable:
             avg_tip = self.tips_avg[-1] if len(self.tips_avg)>0 else 0
             base_fee = self.base_fee[-1] if len(self.base_fee)>0 else 0
             cc_diff = self.cc_diff[-1] if len(self.cc_diff)>0 else 0
-            rt_range.set_description('epoch: {}, fork: {}, winners: {}, issuance {} DRK, f: {}, acc: {}%, stake: {}%, sr: {}%, reward:{}, apr: {}%, basefee: {}, avg(fee): {}, cc_diff: {}, avg(y): {}, avg(T): {}'.format(int(slot/EPOCH_LENGTH), self.merge_length(), self.winners[-1], round(self.Sigma,2), round(f, 5), round(acc*100, 2), round(total_stake/self.Sigma*100 if self.Sigma>0 else 0,2), round(self.avg_stake_ratio()*100,2) , round(self.rewards[-1],2), round(self.avg_apr()*100,2), round(base_fee, 4),  round(avg_tip, 2), round(cc_diff, 2), round(float(avg_y), 2), round(float(avg_t), 2)))
+            rt_range.set_description('epoch: {}, fork: {}, winners: {}, issuance {} DRK, f: {}, acc: {}%, stake: {}%, sr: {}%, reward:{}, apr: {}%, basefee: {}, avg(fee): {}, cc_diff: {}, avg(y): {}, avg(T): {}'.format(int(slot/EPOCH_LENGTH), self.merge_length(), self.winners[-1], round(self.Sigma,2), round(f, 5), round(self.secondary_pid.acc()*100, 2), round(total_stake/self.Sigma*100 if self.Sigma>0 else 0,2), round(self.avg_stake_ratio()*100,2) , round(self.rewards[-1],2), round(self.avg_apr()*100,2), round(base_fee, 5),  round(avg_tip, 2), round(cc_diff, 5), round(float(avg_y), 2), round(float(avg_t), 2)))
             #assert round(total_stake,1) <= round(self.Sigma,1), 'stake: {}, sigma: {}'.format(total_stake, self.Sigma)
             slot+=1
         self.end_time=time.time()
@@ -153,14 +154,15 @@ class DarkfiTable:
         self.tips_avg += [tips/len(idxs) if len(idxs)>0 else 0]
         basefee = self.basefee_pid.pid_clipped(self.computational_cost[-1], debug)
         self.base_fee+=[basefee]
+        assert tips == sum(txs[idx].tip for idx in idxs), 'tips: {}, sum(tips): {}'.format(tips, sum(tx.tip for tx in txs))
         for idx in idxs:
-            fee = txs[idx].cc()+basefee
+            fee = txs[idx].tip+basefee
             self.darkies[idx].pay_fee(fee)
             #print("charging darkie[{}]: {} DRK per tx of length: {}, burning: {}".format(idx, fee, len(txs[idx]), basefee))
         self.darkies[darkie_lead_idx].pay_fee(-1*tips)
 
         # subtract base fee from total stake
-        self.Sigma -= basefee*len(txs)
+        self.Sigma -= basefee*len(idxs)
 
     """
     average APY (with compound interest added every epoch) ,

script/research/lotterysim/core/strategy.py

@@ -12,7 +12,7 @@ class Strategy(object):
         self.epoch_len = epoch_len
         self.airdrop_period=HEADSTART_AIRDROP
         self.staked_tokens_ratio = [1]
-        self.target_apy = TARGET_APR
+        self.target = TARGET_APR
         self.annual_return = [0]
         self.type = 'base'
 
@@ -39,7 +39,7 @@ class LinearStrategy(Strategy):
 
     def set_ratio(self, slot, apr):
         if slot%self.epoch_len==0:
-                sr = Num(apr)/Num(self.target_apy)
+                sr = Num(apr)/Num(self.target)
                 if sr>1:
                     sr = 1
                 elif sr<0:
@@ -54,7 +54,7 @@ class LogarithmicStrategy(Strategy):
 
     def set_ratio(self, slot, apr):
         if slot%self.epoch_len==0:
-                apr_ratio = math.fabs(apr/self.target_apy)
+                apr_ratio = math.fabs(apr/self.target)
                 fn = lambda x: (math.log(x, 10)+1)/2 * 0.95 + 0.05
                 sr = Num(fn(apr_ratio) if apr_ratio != 0 else 0)
                 if sr>1:
@@ -71,7 +71,7 @@ class SigmoidStrategy(Strategy):
 
     def set_ratio(self, slot, apr):
         if slot%self.epoch_len==0:
-                apr_ratio = apr/self.target_apy
+                apr_ratio = apr/self.target
                 apr_ratio = max(apr_ratio, 0)
                 sr = Num(2/(1+math.pow(math.e, -4*apr_ratio))-1)
                 if sr>1: