[research/lotterysim] add finalization resync reward randomly

script/research/lotterysim/acc_vs_staked_ratio.py

@@ -7,7 +7,7 @@ os.system("rm log/f_output.hist; rm log/f_feedback.hist")
 
 RUNNING_TIME = int(input("running time:"))
 ERC20DRK=2.1*10**9
-NODES=1000
+NODES=100
 plot = []
 EXPS=10
 for portion in range(1,11):
@@ -15,7 +15,7 @@ for portion in range(1,11):
     for _ in range(EXPS):
         darkies = []
         egalitarian = ERC20DRK/NODES
-        darkies += [ Darkie(random.gauss(egalitarian, egalitarian*0.1), commit=False) for id in range(int(NODES/portion)) ]
+        darkies += [ Darkie(random.gauss(egalitarian, egalitarian*0.1), commit=False, strategy=Hodler(EPOCH_LENGTH)) for id in range(int(NODES/portion)) ]
         #darkies += [Darkie() for _ in range(NODES*2)]
         airdrop = ERC20DRK
         effective_airdrop  = 0
@@ -23,7 +23,7 @@ for portion in range(1,11):
             effective_airdrop+=darkie.stake
         stake_portion = effective_airdrop/airdrop*100
         print("network airdrop: {}, staked token: {}/{}% on {} nodes".format(airdrop, effective_airdrop, stake_portion, len(darkies)))
-        dt = DarkfiTable(airdrop, RUNNING_TIME, CONTROLLER_TYPE_DISCRETE, kp=0.005999999999989028, ki=-0.005999999985257798, kd=0.01299999999999478)
+        dt = DarkfiTable(airdrop, RUNNING_TIME, CONTROLLER_TYPE_DISCRETE, kp=0.005999999999989028, ki=-0.005999999985257798, kd=0.01299999999999478, r_kp=0.051, r_ki=-0.3229, r_kd=-0.008)
         for darkie in darkies:
             dt.add_darkie(darkie)
         acc, apy, reward, staked_ratio, apr = dt.background(rand_running_time=False)

script/research/lotterysim/core/constants.py

@@ -12,14 +12,14 @@ F_MIN = 0.0001
 F_MAX = 0.9999
 
 REWARD_MIN = 0
-REWARD_MAX = 100
+REWARD_MAX = 10
 
 SLOT = 90
 ONE_YEAR = Num(365.25*24*60*60/SLOT)
 
-TARGET_APR = Num(1)
+TARGET_APR = Num(0.1)
 
-PRIMARY_REWARD_TARGET = 0.5 # ratio of staked tokens
+PRIMARY_REWARD_TARGET = 0.33 # ratio of staked tokens
 SECONDARY_LEAD_TARGET = 1 #number of lead per slot
 
 EPSILON = 1

script/research/lotterysim/core/darkie.py

@@ -6,17 +6,16 @@ class Darkie():
         self.vesting = [0] + vesting
         self.stake = (Num(airdrop) if hp else airdrop)
         self.initial_stake = [self.stake] # for debugging purpose
-        self.finalized_stake = (Num(airdrop) if hp else airdrop)
         self.Sigma = None
         self.feedback = None
         self.f = None
-        self.won=False
         self.epoch_len=epoch_len # epoch length during which the stake is static
         self.strategy = strategy
         self.slot = 0
+        self.won_hist = [] # winning history boolean
 
     def clone(self):
-        return Darkie(self.finalized_stake)
+        return Darkie(self.stake)
 
     def apy_scaled_to_runningtime(self, rewards):
         avg_apy = 0
@@ -65,9 +64,10 @@ class Darkie():
             # staked ratio is added in strategy
             self.strategy.set_ratio(self.slot, apr)
             # epoch stake is added
-            self.initial_stake +=[self.finalized_stake]
-        T = target(self.f, self.strategy.staked_value(self.finalized_stake))
-        self.won = lottery(T, hp)
+            self.initial_stake +=[self.stake]
+        T = target(self.f, self.strategy.staked_value(self.stake))
+        won = lottery(T, hp)
+        self.won_hist += [won]
 
     def update_vesting(self):
         if self.slot >= len(self.vesting):
@@ -81,28 +81,20 @@ class Darkie():
         return vesting_value
 
     def update_stake(self, reward):
-        if self.won:
+        if self.won_hist[-1]:
             self.stake+=reward
             #print('updating stake, stake: {}, last: {}'.format(self.stake, self.initial_stake[-1]))
 
-    def finalize_stake(self):
+    def resync_stake(self, reward):
         '''
-        finalize stake if there is single leader
+        add resync stake
         '''
-        if self.won:
-            #print('finalizing stake')
-            self.finalized_stake = self.stake
-        #else:
-            #self.stake = self.finalized_stake
-
-    def log_state_gain(self):
-        # darkie started with self.initial_stake, self.initial_stake/self.Sigma percent
-        # over the course of self.slot
-        # current stake is self.stake, self.stake/self.Sigma percent
-        pass
+        self.stake += reward
+
 
     def write(self, idx):
         with open('log/darkie'+str(idx)+'.log', 'w+') as f:
             buf = 'initial stake:'+','.join([str(i) for i in self.initial_stake])
             buf += '\r\n'
             buf += 'staked ratio:'+','.join([str(i) for i in self.strategy.staked_tokens_ratio])
+            f.write(buf)

script/research/lotterysim/core/lottery.py

@@ -16,6 +16,7 @@ class DarkfiTable:
         self.primary_pid = PrimaryDiscretePID(kp=r_kp, ki=r_ki, kd=r_kd) if controller_type==CONTROLLER_TYPE_DISCRETE else PrimaryTakahashiPID(kc=kc, ti=ti, td=td, ts=ts)
         self.debug=debug
         self.rewards = []
+        self.winners = []
 
     def add_darkie(self, darkie):
         self.darkies+=[darkie]
@@ -39,7 +40,8 @@ class DarkfiTable:
 
             if count%EPOCH_LENGTH == 0:
                 acc = self.secondary_pid.acc_percentage()
-                reward = self.primary_pid.pid_clipped(acc, debug)
+                #staked_ratio = self.avg_stake_ratio()
+                reward = self.primary_pid.pid_clipped(float(acc), debug)
                 self.rewards += [reward]
 
             #note! thread overhead is 10X slower than sequential node execution!
@@ -51,16 +53,38 @@ class DarkfiTable:
 
             #print('reward: {}'.format(rewards[-1]))
             for i in range(len(self.darkies)):
-                winners += self.darkies[i].won
-                self.darkies[i].update_stake(self.rewards[-1])
+                winners += self.darkies[i].won_hist[-1]
                 ###
-
+            self.winners +=[winners]
             feedback = winners
-            if winners==1:
+            if self.winners[-1]==1:
+                for i in range(len(self.darkies)):
+                    if self.darkies[i].won_hist[-1]:
+                        self.darkies[i].update_stake(self.rewards[-1])
+                        break
+                # resolve finalization
                 if count >= ERC20DRK:
                     self.Sigma += 1
-                for i in range(len(self.darkies)):
-                    self.darkies[i].finalize_stake()
+                # resync nodes
+                merge_length = 0
+                for i in reversed(self.winners[:-1]):
+                    if i !=1:
+                        merge_length+=1
+                    else:
+                        break
+                for i in range(merge_length):
+                    resync_slot_id = count-(i+1)
+                    resync_reward_id = int((resync_slot_id)/EPOCH_LENGTH)
+                    resync_reward = self.rewards[resync_reward_id]
+                    # resyncing depends on the random branch chosen,
+                    # it's simulated by choosing first wining node
+                    darkie_winning_idx = 0
+                    for darkie_idx in range(len(self.darkies)):
+                        if self.darkies[darkie_idx].won_hist[resync_slot_id]:
+                            darkie_winning_idx = darkie_idx
+                            break
+                    self.darkies[darkie_winning_idx].resync_stake(resync_reward)
+
             count+=1
         self.end_time=time.time()
         avg_reward = sum(self.rewards)/len(self.rewards)

script/research/lotterysim/core/strategy.py

@@ -14,6 +14,15 @@ class Strategy(object):
     def staked_value(self, stake):
         return Num(self.staked_tokens_ratio[-1])*Num(stake)
 
+class Hodler(Strategy):
+    def __init__(self, epoch_len):
+        super().__init__(epoch_len)
+        self.type = 'holder'
+
+    def set_ratio(self, slot, apy):
+        if slot%self.epoch_len==0:
+            self.staked_tokens_ratio += [1]
+
 class RandomStrategy(Strategy):
     def __init__(self, epoch_len):
         super().__init__(epoch_len)

script/research/lotterysim/discrete_instance.py

@@ -23,7 +23,7 @@ if __name__ == "__main__":
     for darkie in darkies:
         effective_airdrop+=darkie.stake
     print("network airdrop: {}, staked token: {}/{}% on {} nodes".format(airdrop, effective_airdrop, effective_airdrop/airdrop*100, len(darkies)))
-    dt = DarkfiTable(airdrop, RUNNING_TIME, CONTROLLER_TYPE_DISCRETE, kp=-0.010399999999938556, ki=-0.0365999996461878, kd=0.03840000000000491,  r_kp=-0.1345, r_ki=-0.5, r_kd=-0.5)
+    dt = DarkfiTable(airdrop, RUNNING_TIME, CONTROLLER_TYPE_DISCRETE, kp=-0.010399999999938556, ki=-0.0365999996461878, kd=0.03840000000000491,  r_kp=0.17, r_ki=-0.09, r_kd=1.1)
     for darkie in darkies:
         dt.add_darkie(darkie)
     acc, avg_apy, avg_reward, stake_ratio, avg_apr = dt.background(rand_running_time=False)