Fixed withdrawing

Author: vub

ethereum/casper_contract.py

@@ -4,8 +4,6 @@
 minValidatorSize = 32
 # Largest allowed validator size
 maxValidatorSize = 131072
-# Base block reward
-BLOCK_REWARD = 10**17
 # An epoch number that represents a validator "intending to stay forever"
 NO_END_EPOCH = 2**99
 # Address of "system" entry point
@@ -26,8 +24,10 @@
 data validatorSlotQueue[2**40][2**40]
 # Length of the queue
 data validatorSlotQueueLength[2**40]
+# Total amount of ETH deposited by active validators
+data totalActiveDeposits
 # Total amount of ETH deposited
-data totalDeposits
+data currentTotalDeposits
 # Total amount of ETH deposited during previous epochs
 data historicalTotalDeposits[2**40]
 # Keep track of future changes to total deposits
@@ -68,10 +68,10 @@
         $w * (1 - 2 * ($w < 0))
 
 def const getBlockReward():
-    return(max(self.totalDeposits, 1000000 * 10**18) * BLOCK_MAKING_PPB / 1000000000)
+    return(max(self.currentTotalDeposits, 1000000 * 10**18) * BLOCK_MAKING_PPB / 1000000000)
 
-def const getLockDuration():
-    return(max(min(self.totalDeposits / 10**18 / 2, 10000000), self.epochLength * 2))
+def const getCurrentLockDuration():
+    return(max(min(self.currentTotalDeposits / 10**18 / 2, 10000000), self.epochLength * 2))
 
 def const getEpochLength():
     return(self.epochLength)
@@ -94,7 +94,7 @@ def const getValidatorCount(i):
 def const getHistoricalTotalDeposits(epoch):
     return(self.historicalTotalDeposits[epoch])
 
-def deposit(validation_code:str, randao):
+def deposit(validation_code:str, randao, address):
     # Deposit too small
     if msg.value < minValidatorSize * 10**18:
         ~invalid()
@@ -129,9 +129,10 @@ def deposit(validation_code:str, randao):
     self.validators[i][j].origDeposit = msg.value
     self.validators[i][j].start_epoch = self.currentEpoch + 2
     self.validators[i][j].end_epoch = NO_END_EPOCH
-    self.validators[i][j].address = msg.sender
+    self.validators[i][j].address = address
     self.validators[i][j].randao = randao
-    self.validators[i][j].lock_duration = self.getLockDuration()
+    self.currentTotalDeposits += msg.value
+    self.validators[i][j].lock_duration = self.getCurrentLockDuration()
     self.totalDepositDeltas[self.validators[i][j].start_epoch] += msg.value
     ~sstorebytes(ref(self.vchashToIndices[validation_code_hash]), [i, j], 64)
     log(type=NewValidator)
@@ -145,12 +146,12 @@ def newEpoch(epoch):
     while q < len(validatorSizes):
         self.historicalValidatorCounts[epoch][q] = self.validatorCounts[q]
         q += 1
-    self.totalDeposits += self.totalDepositDeltas[epoch]
-    self.historicalTotalDeposits[epoch] = self.totalDeposits
+    self.totalActiveDeposits += self.totalDepositDeltas[epoch]
+    self.historicalTotalDeposits[epoch] = self.totalActiveDeposits
     self.currentEpoch = epoch
 
 def const getTotalDeposits():
-    return(self.totalDeposits)
+    return(self.currentTotalDeposits)
 
 def const getBlockNumber():
     return(self.blockNumber)
@@ -448,13 +449,18 @@ def const getEndEpoch(vchash:bytes32):
     extractIndices(ref(i), ref(j), vchash)
     return(self.validators[i][j].end_epoch)
 
+def const getLockDuration(vchash:bytes32):
+    extractIndices(ref(i), ref(j), vchash)
+    return(self.validators[i][j].lock_duration)
+
 def const getCurrentEpoch():
     return(self.currentEpoch)
 
 # Finalize withdrawing and take one's money out
 def withdraw(vchash:bytes32):
     extractIndices(ref(i), ref(j), vchash)
-    if self.validators[i][j].end_epoch * self.epochLength + self.validators[i][j].lock_duration < block.timestamp:
+    if self.validators[i][j].end_epoch * self.epochLength + self.validators[i][j].lock_duration <= block.number:
+        self.currentTotalDeposits -= self.validators[i][j].origDeposit
         send(self.validators[i][j].address, self.validators[i][j].deposit)
         self.validators[i][j].deposit = 0
         self.validatorSlotQueue[i][self.validatorSlotQueueLength[i]] = j

ethereum/casper_utils.py

@@ -184,10 +184,10 @@ def make_casper_genesis(validators, alloc, timestamp=0, epoch_length=100):
     t = Transaction(0, 0, 10**8, casper_config['CASPER_ADDR'], 0, ct.encode('initialize', [timestamp, epoch_length, 0, 4712388]))
     apply_transaction(state, t)
     # Add validators
-    for i, (vcode, deposit_size, randao_commitment) in enumerate(validators):
+    for i, (vcode, deposit_size, randao_commitment, address) in enumerate(validators):
         state.set_balance(utils.int_to_addr(1), deposit_size)
         t = Transaction(i, 0, 10**8, casper_config['CASPER_ADDR'], deposit_size,
-                        ct.encode('deposit', [vcode, randao_commitment]))
+                        ct.encode('deposit', [vcode, randao_commitment, address]))
         t._sender = utils.int_to_addr(1)
         success = apply_transaction(state, t)
         assert success
@@ -210,7 +210,7 @@ def make_casper_genesis(validators, alloc, timestamp=0, epoch_length=100):
     t._sender = casper_config['CASPER_ADDR']
     apply_transaction(state, t)
     assert call_casper(state, 'getEpoch', []) == 0
-    assert call_casper(state, 'getTotalDeposits', []) == sum([d for a,d,r in validators])
+    assert call_casper(state, 'getTotalDeposits', []) == sum([d for a,d,r,a in validators])
     state.commit()
     return state
 

ethereum/tests/test_pos.py

@@ -25,12 +25,13 @@
 configure_logging(config_string=config_string)
 
 NUM_PARTICIPANTS = 10
+BLOCK_MAKING_PPB = 10
 
 print 'Initializing privkeys, addresses and randaos for validators'
 privkeys = [utils.sha3(str(i)) for i in range(NUM_PARTICIPANTS)]
 addrs = [utils.privtoaddr(k) for k in privkeys]
 randaos = [RandaoManager(utils.sha3(str(i))) for i in range(NUM_PARTICIPANTS)]
-deposit_sizes = [i * 50 + 50 for i in range(NUM_PARTICIPANTS)]
+deposit_sizes = [i * 500 + 500 for i in range(NUM_PARTICIPANTS)]
 vcodes = [generate_validation_code(a) for a in addrs]
 vchashes = [utils.sha3(c) for c in vcodes]
 assert len(privkeys) == len(addrs) == len(randaos) == len(deposit_sizes) == len(vcodes) == len(vchashes) == NUM_PARTICIPANTS
@@ -39,13 +40,17 @@
 ct = get_casper_ct()
 assert ct
 print 'Constructing genesis'
-s = make_casper_genesis(validators=[(generate_validation_code(a), ds * 10**18, r.get(9999))
+s = make_casper_genesis(validators=[(generate_validation_code(a), ds * 10**18, r.get(9999), a)
                                     for a, ds, r in zip(addrs, deposit_sizes, randaos)][:-1],
                         alloc={a: {'balance': 10**18} for a in addrs},
                         timestamp=int(time.time() - 99999),
                         epoch_length=100)
 print 'Genesis constructed successfully'
 chains = [Chain(s.to_snapshot(), env=s.env) for i in range(NUM_PARTICIPANTS)]
+withdrawal_time_1 = call_casper(chains[0].state, 'getLockDuration', [vchashes[0]])
+
+# List of validator IDs that created each block
+vids = []
 
 # Create and sign a block
 def make_block(chain, key, randao, vchash, skips):
@@ -68,6 +73,7 @@ def make_block(chain, key, randao, vchash, skips):
 assert validate_block_header(s, b.header)
 print 'Validation successful'
 assert chains[0].add_block(b)
+vids.append(next_validator_id)
 print 'Block added to chain'
 # Make another block
 next_validator = call_casper(chains[0].state, 'getValidator', [0])
@@ -77,6 +83,7 @@ def make_block(chain, key, randao, vchash, skips):
 b2 = make_block(chains[0], privkeys[next_validator_id],
                 randaos[next_validator_id], vchashes[next_validator_id], skip_count)
 assert chains[0].add_block(b2)
+vids.append(next_validator_id)
 print 'Second block added to chain'
 # Make a dunkle and include it in a transaction
 next_validator = call_casper(chains[1].state, 'getValidator', [1])
@@ -108,7 +115,6 @@ def make_block(chain, key, randao, vchash, skips):
 chains[0].state.commit()
 print 'Added new validator "in-flight", indices:', vchashes[-1].encode('hex')
 # Create some blocks
-vids = []
 bn = call_casper(chains[0].state, 'getBlockNumber')
 for i in range(bn + 1, 200):
     next_validator = call_casper(chains[0].state, 'getValidator', [0])
@@ -128,6 +134,7 @@ def make_block(chain, key, randao, vchash, skips):
 assert call_casper(chains[0].state, 'getEndEpoch', [vchashes[0]]) == 4
 chains[0].state.commit()
 print 'Withdrew a validator'
+print '%d blocks before ETH becomes available' % withdrawal_time_1
 for i in range(200, 400):
     next_validator = call_casper(chains[0].state, 'getValidator', [0])
     next_validator_id = vchashes.index(next_validator)
@@ -139,14 +146,26 @@ def make_block(chain, key, randao, vchash, skips):
 print 'Created 200 blocks after the deposit, created by validators:', vids[-200:]
 assert len(vchashes) - 1 in vids
 assert 0 in vids
-for i in range(400, 600):
+for i in range(400, 400 + withdrawal_time_1 + 1):
     next_validator = call_casper(chains[0].state, 'getValidator', [0])
     next_validator_id = vchashes.index(next_validator)
     b = make_block(chains[0], privkeys[next_validator_id], randaos[next_validator_id],
                    vchashes[next_validator_id], 0)
     assert chains[0].add_block(b)
     vids.append(next_validator_id)
-print 'Created 200 blocks after the withdrawal, created by validators:', vids[-200:]
+print 'Created %d blocks after the withdrawal, created by validators:' % (withdrawal_time_1 + 1), vids[-200:]
 assert len(vchashes) - 1 in vids
 assert 0 not in vids[-200:]
+pre_bal = chains[0].state.get_balance(addrs[0])
+txdata = ct.encode('withdraw', [vchashes[0]])
+t4 = Transaction(chains[0].state.get_nonce(addrs[0]), 0, 1000000, casper_config['CASPER_ADDR'], 0, txdata).sign(privkeys[0])
+apply_transaction(chains[0].state, t4)
+post_bal = chains[0].state.get_balance(addrs[0])
+print 'Wei withdrawn:', post_bal - pre_bal
+blocks_by_v0_in_stage1 = len([x for x in vids[:200] if x == 0])
+expected_revenue_in_stage1 = blocks_by_v0_in_stage1 * max(sum(deposit_sizes[:-1]), 1000000) * 10**18 * BLOCK_MAKING_PPB / 10**9
+blocks_by_v0_in_stage2 = len([x for x in vids[200:400] if x == 0])
+expected_revenue_in_stage2 = blocks_by_v0_in_stage2 * max(sum(deposit_sizes), 1000000) * 10**18 * BLOCK_MAKING_PPB / 10**9
+
+assert post_bal - pre_bal == deposit_sizes[0] * 10**18 + expected_revenue_in_stage1 + expected_revenue_in_stage2
 print 'PoS test fully passed'