diff --git a/python/tests/test_basic.py b/python/tests/test_basic.py index 01ea18c..e1a07a9 100644 --- a/python/tests/test_basic.py +++ b/python/tests/test_basic.py @@ -3,6 +3,7 @@ import os import unittest import json import logging +import datetime # third-party imports import web3 @@ -18,9 +19,11 @@ logging.getLogger('eth.vm').setLevel(logging.WARNING) testdir = os.path.dirname(__file__) #BLOCKTIME = 5 # seconds -TAX_LEVEL = 10000 * 2 # 2% +TAX_LEVEL = int(10000 * 2) # 2% +# calc "1-(0.98)^(1/518400)" <- 518400 = 30 days of blocks +# 0.00000003897127107225 #PERIOD = int(60/BLOCKTIME) * 60 * 24 * 30 # month -PERIOD = 10 +PERIOD = 1 class Test(unittest.TestCase): @@ -48,12 +51,15 @@ class Test(unittest.TestCase): self.sink_address = self.w3.eth.accounts[9] c = self.w3.eth.contract(abi=self.abi, bytecode=self.bytecode) - tx_hash = c.constructor('Foo Token', 'FOO', 6, TAX_LEVEL, PERIOD, self.sink_address).transact({'from': self.w3.eth.accounts[0]}) + tx_hash = c.constructor('Foo Token', 'FOO', 6, TAX_LEVEL * (10 ** 32), PERIOD, self.sink_address).transact({'from': self.w3.eth.accounts[0]}) r = self.w3.eth.getTransactionReceipt(tx_hash) self.contract = self.w3.eth.contract(abi=self.abi, address=r.contractAddress) self.start_block = self.w3.eth.blockNumber + b = self.w3.eth.getBlock(self.start_block) + self.start_time = b['timestamp'] + def tearDown(self): pass @@ -61,10 +67,31 @@ class Test(unittest.TestCase): def test_hello(self): self.assertEqual(self.contract.functions.actualPeriod().call(), 1) - self.eth_tester.mine_blocks(PERIOD) + self.eth_tester.time_travel(self.start_time + 61) self.assertEqual(self.contract.functions.actualPeriod().call(), 2) + + def test_apply_demurrage(self): + modifier = 10 * (10 ** 37) + demurrage_modifier = self.contract.functions.demurrageModifier().call() + demurrage_modifier &= (1 << 128) - 1 + self.assertEqual(modifier, demurrage_modifier) + + self.eth_tester.time_travel(self.start_time + 59) + demurrage_modifier = self.contract.functions.demurrageModifier().call() + demurrage_modifier &= (1 << 128) - 1 + self.assertEqual(modifier, demurrage_modifier) + + self.eth_tester.time_travel(self.start_time + 61) + tx_hash = self.contract.functions.applyDemurrage().transact() + r = self.w3.eth.getTransactionReceipt(tx_hash) + + demurrage_modifier = self.contract.functions.demurrageModifier().call() + demurrage_modifier &= (1 << 128) - 1 + self.assertEqual(int(98 * (10 ** 36)), demurrage_modifier) + + def test_mint(self): tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[1], 1024).transact() r = self.w3.eth.getTransactionReceipt(tx_hash) @@ -80,6 +107,26 @@ class Test(unittest.TestCase): balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() self.assertEqual(balance, 2000) + self.eth_tester.time_travel(self.start_time + 61) + balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() + self.assertEqual(balance, int(2000 * 0.98)) + + + def test_base_amount(self): + tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[1], 1000).transact() + r = self.w3.eth.getTransactionReceipt(tx_hash) + self.assertEqual(r.status, 1) + + self.eth_tester.time_travel(self.start_time + 61) + + self.contract.functions.applyDemurrage().transact() + demurrage_modifier = self.contract.functions.demurrageModifier().call() + demurrage_amount = self.contract.functions.toDemurrageAmount(demurrage_modifier).call() + logg.debug('d {} {}'.format(demurrage_modifier.to_bytes(32, 'big').hex(), demurrage_amount)) + + a = self.contract.functions.toBaseAmount(1000).call(); + self.assertEqual(a, 1020) + def test_transfer(self): tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[1], 1024).transact() @@ -128,60 +175,5 @@ class Test(unittest.TestCase): self.assertEqual(balance_alice, 500) - def test_apply_tax(self): - self.eth_tester.mine_blocks(PERIOD) - tx_hash = self.contract.functions.applyTax().transact() - r = self.w3.eth.getTransactionReceipt(tx_hash) - self.assertEqual(self.contract.functions.redistributionCount().call(), 2) - self.assertEqual(self.contract.functions.demurrageModifier().call(), 980000) - - self.eth_tester.mine_blocks(PERIOD) - tx_hash = self.contract.functions.applyTax().transact() - r = self.w3.eth.getTransactionReceipt(tx_hash) - self.assertEqual(self.contract.functions.redistributionCount().call(), 3) - self.assertEqual(self.contract.functions.demurrageModifier().call(), 960400) - - - def test_tax_balance(self): - tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[1], 1000).transact() - r = self.w3.eth.getTransactionReceipt(tx_hash) - self.assertEqual(r.status, 1) - - self.eth_tester.mine_blocks(PERIOD) - tx_hash = self.contract.functions.applyTax().transact() - r = self.w3.eth.getTransactionReceipt(tx_hash) - self.assertEqual(r.status, 1) - - balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() - self.assertEqual(balance, 980) - - - def test_taxed_transfer(self): - tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[1], 1000000).transact() - r = self.w3.eth.getTransactionReceipt(tx_hash) - self.assertEqual(r.status, 1) - - self.eth_tester.mine_blocks(PERIOD) - tx_hash = self.contract.functions.applyTax().transact() - r = self.w3.eth.getTransactionReceipt(tx_hash) - self.assertEqual(r.status, 1) - - balance_alice = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() - self.assertEqual(balance_alice, 980000) - - tx_hash = self.contract.functions.transfer(self.w3.eth.accounts[2], 500000).transact({'from': self.w3.eth.accounts[1]}) - r = self.w3.eth.getTransactionReceipt(tx_hash) - logg.debug('r {}'.format(r)) - self.assertEqual(r.status, 1) - - balance_alice = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() - balance_alice_trunc = int(balance_alice/1000)*1000 - self.assertEqual(balance_alice_trunc, 480000) - - balance_bob = self.contract.functions.balanceOf(self.w3.eth.accounts[2]).call() - balance_bob_trunc = int(balance_bob/1000)*1000 - self.assertEqual(balance_bob_trunc, 500000) - - if __name__ == '__main__': unittest.main() diff --git a/python/tests/test_period.py b/python/tests/test_period.py new file mode 100644 index 0000000..5f7a60a --- /dev/null +++ b/python/tests/test_period.py @@ -0,0 +1,80 @@ +# standard imports +import os +import unittest +import json +import logging + +# third-party imports +import web3 +import eth_tester +import eth_abi + +logging.basicConfig(level=logging.DEBUG) +logg = logging.getLogger() + +logging.getLogger('web3').setLevel(logging.WARNING) +logging.getLogger('eth.vm').setLevel(logging.WARNING) + +testdir = os.path.dirname(__file__) + +#BLOCKTIME = 5 # seconds +TAX_LEVEL = 10000 * 2 # 2% +#PERIOD = int(60/BLOCKTIME) * 60 * 24 * 30 # month +PERIOD = 1 + + +class Test(unittest.TestCase): + + contract = None + + def setUp(self): + eth_params = eth_tester.backends.pyevm.main.get_default_genesis_params({ + 'gas_limit': 9000000, + }) + + f = open(os.path.join(testdir, '../../solidity/RedistributedDemurrageToken.bin'), 'r') + self.bytecode = f.read() + f.close() + + f = open(os.path.join(testdir, '../../solidity/RedistributedDemurrageToken.json'), 'r') + self.abi = json.load(f) + f.close() + + backend = eth_tester.PyEVMBackend(eth_params) + self.eth_tester = eth_tester.EthereumTester(backend) + provider = web3.Web3.EthereumTesterProvider(self.eth_tester) + self.w3 = web3.Web3(provider) + self.sink_address = self.w3.eth.accounts[9] + + c = self.w3.eth.contract(abi=self.abi, bytecode=self.bytecode) + tx_hash = c.constructor('Foo Token', 'FOO', 6, TAX_LEVEL * (10 ** 32), PERIOD, self.sink_address).transact({'from': self.w3.eth.accounts[0]}) + + r = self.w3.eth.getTransactionReceipt(tx_hash) + self.contract = self.w3.eth.contract(abi=self.abi, address=r.contractAddress) + + self.start_block = self.w3.eth.blockNumber + b = self.w3.eth.getBlock(self.start_block) + self.start_time = b['timestamp'] + + + def tearDown(self): + pass + + + def test_period(self): + tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[1], 1024).transact() + r = self.w3.eth.getTransactionReceipt(tx_hash) + self.assertEqual(r.status, 1) + + self.eth_tester.time_travel(self.start_time + 61) + tx_hash = self.contract.functions.changePeriod().transact() + r = self.w3.eth.getTransactionReceipt(tx_hash) + self.assertEqual(r.status, 1) + + redistribution = self.contract.functions.redistributions(1).call() + self.assertEqual(2, self.contract.functions.toRedistributionPeriod(redistribution).call()) + self.assertEqual(2, self.contract.functions.actualPeriod().call()) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/tests/test_pure.py b/python/tests/test_pure.py new file mode 100644 index 0000000..54665e2 --- /dev/null +++ b/python/tests/test_pure.py @@ -0,0 +1,107 @@ +# standard imports +import os +import unittest +import json +import logging +import math + +# third-party imports +import web3 +import eth_tester +import eth_abi + +logging.basicConfig(level=logging.DEBUG) +logg = logging.getLogger() + +logging.getLogger('web3').setLevel(logging.WARNING) +logging.getLogger('eth.vm').setLevel(logging.WARNING) + +testdir = os.path.dirname(__file__) + +#BLOCKTIME = 5 # seconds +TAX_LEVEL = int((10000 * 2) * (10 ** 32)) # 2% +PERIOD = 10 + + +class Test(unittest.TestCase): + + contract = None + + def setUp(self): + eth_params = eth_tester.backends.pyevm.main.get_default_genesis_params({ + 'gas_limit': 9000000, + }) + + f = open(os.path.join(testdir, '../../solidity/RedistributedDemurrageToken.bin'), 'r') + self.bytecode = f.read() + f.close() + + f = open(os.path.join(testdir, '../../solidity/RedistributedDemurrageToken.json'), 'r') + self.abi = json.load(f) + f.close() + + + backend = eth_tester.PyEVMBackend(eth_params) + self.eth_tester = eth_tester.EthereumTester(backend) + provider = web3.Web3.EthereumTesterProvider(self.eth_tester) + self.w3 = web3.Web3(provider) + self.sink_address = self.w3.eth.accounts[9] + + c = self.w3.eth.contract(abi=self.abi, bytecode=self.bytecode) + tx_hash = c.constructor('Foo Token', 'FOO', 6, TAX_LEVEL, PERIOD, self.sink_address).transact({'from': self.w3.eth.accounts[0]}) + + r = self.w3.eth.getTransactionReceipt(tx_hash) + self.contract = self.w3.eth.contract(abi=self.abi, address=r.contractAddress) + + self.start_block = self.w3.eth.blockNumber + + + def tearDown(self): + pass + + + def test_tax_period(self): + t = self.contract.functions.taxLevel().call() + logg.debug('taxlevel {}'.format(t)) + + a = self.contract.functions.toTaxPeriodAmount(1000000, 0).call() + self.assertEqual(a, 1000000) + + a = self.contract.functions.toTaxPeriodAmount(1000000, 1).call() + self.assertEqual(a, 980000) + + a = self.contract.functions.toTaxPeriodAmount(1000000, 2).call() + self.assertEqual(a, 960400) + + a = self.contract.functions.toTaxPeriodAmount(980000, 1).call() + self.assertEqual(a, 960400) + + + def test_fractional_state(self): + with self.assertRaises(eth_tester.exceptions.TransactionFailed): + self.contract.functions.remainder(2, 1).call(); + + with self.assertRaises(eth_tester.exceptions.TransactionFailed): + remainder = self.contract.functions.remainder(0, 100001).call(); + + remainder = self.contract.functions.remainder(1, 2).call(); + self.assertEqual(remainder, 0); + + whole = 5000001 + parts = 20000 + expect = whole - (math.floor(whole/parts) * parts) + remainder = self.contract.functions.remainder(parts, whole).call(); + self.assertEqual(remainder, expect) + + parts = 30000 + expect = whole - (math.floor(whole/parts) * parts) + remainder = self.contract.functions.remainder(parts, whole).call(); + self.assertEqual(remainder, expect) + + parts = 40001 + expect = whole - (math.floor(whole/parts) * parts) + remainder = self.contract.functions.remainder(parts, whole).call(); + self.assertEqual(remainder, expect) + +if __name__ == '__main__': + unittest.main() diff --git a/python/tests/test_redistribution.py b/python/tests/test_redistribution.py new file mode 100644 index 0000000..9a95911 --- /dev/null +++ b/python/tests/test_redistribution.py @@ -0,0 +1,198 @@ +# standard imports +import os +import unittest +import json +import logging + +# third-party imports +import web3 +import eth_tester +import eth_abi + +logging.basicConfig(level=logging.DEBUG) +logg = logging.getLogger() + +logging.getLogger('web3').setLevel(logging.WARNING) +logging.getLogger('eth.vm').setLevel(logging.WARNING) + +testdir = os.path.dirname(__file__) + +#BLOCKTIME = 5 # seconds +TAX_LEVEL = 10000 * 2 # 2% +#PERIOD = int(60/BLOCKTIME) * 60 * 24 * 30 # month +PERIOD = 1 + + +class Test(unittest.TestCase): + + contract = None + + def setUp(self): + eth_params = eth_tester.backends.pyevm.main.get_default_genesis_params({ + 'gas_limit': 9000000, + }) + + f = open(os.path.join(testdir, '../../solidity/RedistributedDemurrageToken.bin'), 'r') + self.bytecode = f.read() + f.close() + + f = open(os.path.join(testdir, '../../solidity/RedistributedDemurrageToken.json'), 'r') + self.abi = json.load(f) + f.close() + + backend = eth_tester.PyEVMBackend(eth_params) + self.eth_tester = eth_tester.EthereumTester(backend) + provider = web3.Web3.EthereumTesterProvider(self.eth_tester) + self.w3 = web3.Web3(provider) + self.sink_address = self.w3.eth.accounts[9] + + c = self.w3.eth.contract(abi=self.abi, bytecode=self.bytecode) + tx_hash = c.constructor('Foo Token', 'FOO', 6, TAX_LEVEL * (10 ** 32), PERIOD, self.sink_address).transact({'from': self.w3.eth.accounts[0]}) + + r = self.w3.eth.getTransactionReceipt(tx_hash) + self.contract = self.w3.eth.contract(abi=self.abi, address=r.contractAddress) + + self.start_block = self.w3.eth.blockNumber + b = self.w3.eth.getBlock(self.start_block) + self.start_time = b['timestamp'] + + + def tearDown(self): + pass + + + def debug_periods(self): + pactual = self.contract.functions.actualPeriod().call() + pstart = self.contract.functions.periodStart().call() + pduration = self.contract.functions.periodDuration().call() + blocknumber = self.w3.eth.blockNumber; + logg.debug('actual {} start {} duration {} blocknumber {}'.format(pactual, pstart, pduration, blocknumber)) + + + # TODO: check receipt log outputs + def test_redistribution_storage(self): + self.contract.functions.mintTo(self.w3.eth.accounts[1], 1000000).transact() + self.contract.functions.mintTo(self.w3.eth.accounts[2], 1000000).transact() + + external_address = web3.Web3.toChecksumAddress('0x' + os.urandom(20).hex()) + tx_hash = self.contract.functions.transfer(external_address, 1000000).transact({'from': self.w3.eth.accounts[2]}) + tx_hash = self.contract.functions.transfer(external_address, 999999).transact({'from': self.w3.eth.accounts[1]}) + r = self.w3.eth.getTransactionReceipt(tx_hash) + logg.debug('tx before {}'.format(r)) + self.assertEqual(r.status, 1) + + self.eth_tester.time_travel(self.start_time + 61) + + redistribution = self.contract.functions.redistributions(0).call(); + self.assertEqual(redistribution.hex(), '000000000100000000000000000000000000000000001e848000000000000001') + + tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[0], 1000000).transact() + r = self.w3.eth.getTransactionReceipt(tx_hash) + self.assertEqual(r.status, 1) + + redistribution = self.contract.functions.redistributions(1).call() + self.assertEqual(redistribution.hex(), '000000000000000000000000000000000000000000002dc6c000000000000002') + + + def test_redistribution_balance_on_zero_participants(self): + supply = 1000000000000 + tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[1], supply).transact() + r = self.w3.eth.getTransactionReceipt(tx_hash) + + self.eth_tester.time_travel(self.start_time + 61) + + tx_hash = self.contract.functions.applyDemurrage().transact() + r = self.w3.eth.getTransactionReceipt(tx_hash) + logg.debug('r {}'.format(r)) + self.assertEqual(r.status, 1) + tx_hash = self.contract.functions.changePeriod().transact() + rr = self.w3.eth.getTransactionReceipt(tx_hash) + self.assertEqual(rr.status, 1) + + redistribution = self.contract.functions.redistributions(0).call(); + supply = self.contract.functions.totalSupply().call() + + sink_increment = int(supply * (TAX_LEVEL / 1000000)) + for l in r['logs']: + if l.topics[0].hex() == '0xa0717e54e02bd9829db5e6e998aec0ae9de796b8d150a3cc46a92ab869697755': # event Decayed(uint256,uint256,uint256,uint256) + period = int.from_bytes(l.topics[1], 'big') + self.assertEqual(period, 2) + b = bytes.fromhex(l.data[2:]) + remainder = int.from_bytes(b, 'big') + self.assertEqual(remainder, int((1000000 - TAX_LEVEL) * (10 ** 32))) + logg.debug('period {} remainder {}'.format(period, remainder)) + + sink_balance = self.contract.functions.balanceOf(self.sink_address).call() + logg.debug('{} {}'.format(sink_increment, sink_balance)) + self.assertEqual(sink_balance, int(sink_increment * 0.98)) + self.assertEqual(sink_balance, int(sink_increment * (1000000 - TAX_LEVEL) / 1000000)) + + balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() + self.assertEqual(balance, supply - sink_increment) + + + def test_redistribution_two_of_ten(self): + mint_amount = 100000000 + z = 0 + for i in range(10): + self.contract.functions.mintTo(self.w3.eth.accounts[i], mint_amount).transact() + z += mint_amount + + initial_balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() + + spend_amount = 1000000 + external_address = web3.Web3.toChecksumAddress('0x' + os.urandom(20).hex()) + self.contract.functions.transfer(external_address, spend_amount).transact({'from': self.w3.eth.accounts[1]}) + tx_hash = self.contract.functions.transfer(external_address, spend_amount).transact({'from': self.w3.eth.accounts[2]}) + r = self.w3.eth.getTransactionReceipt(tx_hash) + # No cheating! + self.contract.functions.transfer(self.w3.eth.accounts[3], spend_amount).transact({'from': self.w3.eth.accounts[3]}) + # Cheapskate! + self.contract.functions.transfer(external_address, spend_amount-1).transact({'from': self.w3.eth.accounts[4]}) + + self.assertEqual(r.status, 1) + + self.eth_tester.time_travel(self.start_time + 61) + + self.contract.functions.applyDemurrage().transact() + self.contract.functions.changePeriod().transact() + + bummer_balance = self.contract.functions.balanceOf(self.w3.eth.accounts[3]).call() + self.assertEqual(bummer_balance, mint_amount - (mint_amount * (TAX_LEVEL / 1000000))) + logg.debug('bal {} '.format(bummer_balance)) + + bummer_balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() + spender_balance = mint_amount - spend_amount + spender_decayed_balance = int(spender_balance - (spender_balance * (TAX_LEVEL / 1000000))) + self.assertEqual(bummer_balance, spender_decayed_balance) + logg.debug('bal {} '.format(bummer_balance)) + + tx_hash = self.contract.functions.applyRedistributionOnAccount(self.w3.eth.accounts[1]).transact() + r = self.w3.eth.getTransactionReceipt(tx_hash) + logg.debug('log {}'.format(r.logs)) + + self.contract.functions.applyRedistributionOnAccount(self.w3.eth.accounts[2]).transact() + + redistribution_data = self.contract.functions.redistributions(0).call() + logg.debug('redist data {}'.format(redistribution_data.hex())) + + account_period_data = self.contract.functions.accountPeriod(self.w3.eth.accounts[1]).call() + logg.debug('account period {}'.format(account_period_data)) + + actual_period = self.contract.functions.actualPeriod().call() + logg.debug('period {}'.format(actual_period)) + + redistribution = int((z / 2) * (TAX_LEVEL / 1000000)) + spender_new_base_balance = ((mint_amount - spend_amount) + redistribution) + spender_new_decayed_balance = int(spender_new_base_balance - (spender_new_base_balance * (TAX_LEVEL / 1000000))) + + spender_actual_balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call() + logg.debug('rrr {} {}'.format(redistribution, spender_new_decayed_balance)) + + self.assertEqual(spender_actual_balance, spender_new_decayed_balance) + + +if __name__ == '__main__': + unittest.main() + + diff --git a/solidity/RedistributedDemurrageToken.sol b/solidity/RedistributedDemurrageToken.sol index b50131f..1958c51 100644 --- a/solidity/RedistributedDemurrageToken.sol +++ b/solidity/RedistributedDemurrageToken.sol @@ -6,15 +6,17 @@ pragma solidity > 0.6.11; contract RedistributedDemurrageToken { address public owner; - uint256 public decimals; string public name; string public symbol; + uint256 public decimals; uint256 public totalSupply; + uint256 public minimumParticipantSpend; + uint256 constant ppmDivider = 100000000000000000000000000000000; - uint256 public periodStart; - uint256 public periodDuration; - uint256 public taxLevel; // PPM - uint256 public demurrageModifier; // PPM + uint256 public immutable periodStart; // timestamp + uint256 public immutable periodDuration; // duration in SECONDS + uint256 public immutable taxLevel; // PPM per MINUTE + uint256 public demurrageModifier; // PPM uint128(block) | uint128(ppm) bytes32[] public redistributions; // uint1(isFractional) | uint1(unused) | uint38(participants) | uint160(value) | uint56(period) mapping (address => bytes32) account; // uint20(unused) | uint56(period) | uint160(value) @@ -27,22 +29,24 @@ contract RedistributedDemurrageToken { event Approval(address indexed _owner, address indexed _spender, uint256 _value); event Mint(address indexed _minter, address indexed _beneficiary, uint256 _value); //event Debug(uint256 _foo); - event Taxed(uint256 indexed _period, uint256 remainder); + event Decayed(uint256 indexed _period, uint256 indexed _periodCount, uint256 indexed _oldAmount, uint256 _newAmount); event Redistribution(address indexed _account, uint256 indexed _period, uint256 _value); - constructor(string memory _name, string memory _symbol, uint8 _decimals, uint32 _taxLevel, uint256 _period, address _defaultSinkAddress) public { + constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _taxLevelMinute, uint256 _periodMinutes, address _defaultSinkAddress) public { owner = msg.sender; minter[owner] = true; - periodStart = block.number; - periodDuration = _period; - taxLevel = _taxLevel; + periodStart = block.timestamp; + periodDuration = _periodMinutes * 60; name = _name; symbol = _symbol; decimals = _decimals; - demurrageModifier = 1000000; + demurrageModifier = ppmDivider * 1000000; // Emulates 38 decimal places + demurrageModifier |= (1 << 128); + taxLevel = _taxLevelMinute; // 38 decimal places sinkAddress = _defaultSinkAddress; bytes32 initialRedistribution = toRedistribution(0, 0, 1); redistributions.push(initialRedistribution); + minimumParticipantSpend = 10 ** uint256(_decimals); } // Given address will be allowed to call the mintTo() function @@ -51,13 +55,24 @@ contract RedistributedDemurrageToken { minter[_minter] = true; return true; } - + /// ERC20 function balanceOf(address _account) public view returns (uint256) { - uint256 baseBalance = getBaseBalance(_account); - uint256 inverseModifier = 1000000 - demurrageModifier; - uint256 balanceModifier = (inverseModifier * baseBalance) / 1000000; - return baseBalance - balanceModifier; + uint256 baseBalance; + uint256 anchorDemurrageAmount; + uint256 anchorDemurragePeriod; + uint256 currentDemurrageAmount; + uint256 periodCount; + + baseBalance = getBaseBalance(_account); + anchorDemurrageAmount = toDemurrageAmount(demurrageModifier); + anchorDemurragePeriod = toDemurragePeriod(demurrageModifier); + + periodCount = actualPeriod() - toDemurragePeriod(demurrageModifier); + + currentDemurrageAmount = toTaxPeriodAmount(anchorDemurrageAmount, periodCount); + + return (baseBalance * currentDemurrageAmount) / (ppmDivider * 1000000); } /// Balance unmodified by demurrage @@ -69,7 +84,11 @@ contract RedistributedDemurrageToken { function increaseBaseBalance(address _account, uint256 _delta) private returns (bool) { uint256 oldBalance; uint256 newBalance; - + + if (_delta == 0) { + return false; + } + oldBalance = getBaseBalance(_account); newBalance = oldBalance + _delta; require(uint160(newBalance) > uint160(oldBalance), 'ERR_WOULDWRAP'); // revert if increase would result in a wrapped value @@ -83,6 +102,10 @@ contract RedistributedDemurrageToken { uint256 oldBalance; uint256 newBalance; + if (_delta == 0) { + return false; + } + oldBalance = getBaseBalance(_account); require(oldBalance >= _delta, 'ERR_OVERSPEND'); // overspend guard newBalance = oldBalance - _delta; @@ -96,8 +119,8 @@ contract RedistributedDemurrageToken { function mintTo(address _beneficiary, uint256 _amount) external returns (bool) { require(minter[msg.sender]); - // TODO: get base amount for minting - applyTax(); + applyDemurrage(); + changePeriod(); totalSupply += _amount; increaseBaseBalance(_beneficiary, _amount); emit Mint(msg.sender, _beneficiary, _amount); @@ -162,7 +185,7 @@ contract RedistributedDemurrageToken { // Get the demurrage period of the current block number function actualPeriod() public view returns (uint256) { - return (block.number - periodStart) / periodDuration + 1; + return (block.timestamp - periodStart) / periodDuration + 1; } // Add an entered demurrage period to the redistribution array @@ -198,7 +221,7 @@ contract RedistributedDemurrageToken { uint256 truncatedResult; if (_numParts == 0) { // no division by zero please - return _sumWhole; + revert('ERR_NUMPARTS_ZERO'); } require(_numParts < _sumWhole); // At least you are never LESS than the sum of your parts. Think about that. @@ -207,24 +230,79 @@ contract RedistributedDemurrageToken { return _sumWhole - truncatedResult; } + // Called in the edge case where participant number is 0. It will override the participant count to 1. + // Returns the remainder sent to the sink address + function applyDefaultRedistribution(bytes32 _redistribution) private returns (uint256) { + uint256 redistributionSupply; + uint256 redistributionPeriod; + uint256 unit; + uint256 truncatedResult; + + redistributionSupply = toRedistributionSupply(_redistribution); + + unit = (redistributionSupply * taxLevel) / 1000000; + truncatedResult = (unit * 1000000) / taxLevel; + + if (truncatedResult < redistributionSupply) { + redistributionPeriod = toRedistributionPeriod(_redistribution); // since we reuse period here, can possibly be optimized by passing period instead + redistributions[redistributionPeriod-1] &= 0x0000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff; // just to be safe, zero out all participant count data, in this case there will be only one + redistributions[redistributionPeriod-1] |= 0x8000000001000000000000000000000000000000000000000000000000000000; + } + + increaseBaseBalance(sinkAddress, unit / ppmDivider); //truncatedResult); + return unit; + } + // sets the remainder bit for the given period and books the remainder to the sink address balance // returns false if no change was made function applyRemainderOnPeriod(uint256 _remainder, uint256 _period) private returns (bool) { - bytes32 redistribution; - - redistribution = redistributions[_period-1]; + uint256 periodSupply; if (_remainder == 0) { return false; } - redistribution |= 0x8000000000000000000000000000000000000000000000000000000000000000; - increaseBaseBalance(sinkAddress, _remainder); + + redistributions[_period-1] |= 0x8000000000000000000000000000000000000000000000000000000000000000; + + periodSupply = toRedistributionSupply(redistributions[_period-1]); + increaseBaseBalance(sinkAddress, periodSupply - _remainder); + return true; + } + + + function toDemurrageAmount(uint256 _demurrage) public pure returns (uint256) { + return _demurrage & 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff; + } + + function toDemurragePeriod(uint256 _demurrage) public pure returns (uint256) { + return (_demurrage & 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000) >> 128; + } + + function applyDemurrage() public returns (bool) { + uint256 epochPeriodCount; + uint256 periodCount; + uint256 lastDemurrageAmount; + uint256 newDemurrageAmount; + + epochPeriodCount = actualPeriod(); + //epochPeriodCount = (block.timestamp - periodStart) / periodDuration; // toDemurrageTime(demurrageModifier); + periodCount = epochPeriodCount - toDemurragePeriod(demurrageModifier); + if (periodCount == 0) { + return false; + } + lastDemurrageAmount = toDemurrageAmount(demurrageModifier); + newDemurrageAmount = toTaxPeriodAmount(lastDemurrageAmount, periodCount); + demurrageModifier = 0; + demurrageModifier |= (newDemurrageAmount & 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff); + demurrageModifier |= (epochPeriodCount << 128); + emit Decayed(epochPeriodCount, periodCount, lastDemurrageAmount, newDemurrageAmount); return true; } // Recalculate the demurrage modifier for the new period // After this, all REPORTED balances will have been reduced by the corresponding ratio (but the effecive totalsupply stays the same) - function applyTax() public returns (uint256) { + //function applyTax() public returns (uint256) { + function changePeriod() public returns (uint256) { bytes32 currentRedistribution; bytes32 nextRedistribution; uint256 currentPeriod; @@ -235,29 +313,33 @@ contract RedistributedDemurrageToken { if (currentRedistribution == bytes32(0x00)) { return demurrageModifier; } - demurrageModifier -= (demurrageModifier * taxLevel) / 1000000; + //demurrageModifier -= (demurrageModifier * taxLevel) / 1000000; currentPeriod = toRedistributionPeriod(currentRedistribution); nextRedistribution = toRedistribution(0, totalSupply, currentPeriod + 1); redistributions.push(nextRedistribution); currentParticipants = toRedistributionParticipants(currentRedistribution); - currentRemainder = remainder(currentParticipants, totalSupply); // we can use totalSupply directly because it will always be the same as the recorded supply on the current redistribution - applyRemainderOnPeriod(currentRemainder, currentPeriod); - emit Taxed(currentPeriod, currentRemainder); + if (currentParticipants == 0) { + currentRemainder = applyDefaultRedistribution(currentRedistribution); + } else { + currentRemainder = remainder(currentParticipants, totalSupply); // we can use totalSupply directly because it will always be the same as the recorded supply on the current redistribution + applyRemainderOnPeriod(currentRemainder, currentPeriod); + } return demurrageModifier; } // Calculate a value reduced by demurrage by the given period function toTaxPeriodAmount(uint256 _value, uint256 _period) public view returns (uint256) { uint256 valueFactor; + uint256 truncatedTaxLevel; - // TODO: doesn't work for solidity as floats are missing and using ints linearly increases the order of magnitude - // valueFactor = 1000000 * (((1000000-taxLevel)/1000000) ** _period); + // TODO: if can't get to work, reverse the iteration from current period. valueFactor = 1000000; - for (uint256 i = 0; i < _period; i++) { - valueFactor = (valueFactor * taxLevel) / 1000000; - } + truncatedTaxLevel = taxLevel / ppmDivider; + for (uint256 i = 0; i < _period; i++) { + valueFactor = valueFactor - ((valueFactor * truncatedTaxLevel) / 1000000); + } return (valueFactor * _value) / 1000000; } @@ -282,9 +364,8 @@ contract RedistributedDemurrageToken { } supply = toRedistributionSupply(periodRedistribution); - // TODO: Make sure value for balance increases round down, and that we can do a single allocation to a sink account with the difference. We can use the highest bit in "participants" for that. - baseValue = supply / participants; - value = toTaxPeriodAmount(baseValue, period-1); + baseValue = ((supply / participants) * (taxLevel / 1000000)) / ppmDivider; + value = toTaxPeriodAmount(baseValue, period - 1); account[_account] &= bytes32(0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff); increaseBaseBalance(_account, value); @@ -295,7 +376,21 @@ contract RedistributedDemurrageToken { // Inflates the given amount according to the current demurrage modifier function toBaseAmount(uint256 _value) public view returns (uint256) { - return (_value * 1000000) / demurrageModifier; + return (_value * ppmDivider * 1000000) / toDemurrageAmount(demurrageModifier); + } + + // ERC20, triggers tax and/or redistribution + function approve(address _spender, uint256 _value) public returns (bool) { + uint256 baseValue; + + applyDemurrage(); + changePeriod(); + applyRedistributionOnAccount(msg.sender); + + baseValue = toBaseAmount(_value); + allowance[msg.sender][_spender] += baseValue; + emit Approval(msg.sender, _spender, _value); + return true; } // ERC20, triggers tax and/or redistribution @@ -303,7 +398,8 @@ contract RedistributedDemurrageToken { uint256 baseValue; bool result; - applyTax(); + applyDemurrage(); + changePeriod(); applyRedistributionOnAccount(msg.sender); // TODO: Prefer to truncate the result, instead it seems to round to nearest :/ @@ -313,29 +409,14 @@ contract RedistributedDemurrageToken { return result; } - // ERC20 transfer backend for transfer, transferFrom - function transferBase(address _from, address _to, uint256 _value) private returns (bool) { - uint256 period; - - if (!decreaseBaseBalance(_from, _value)) { - revert('ERR_TX_DECREASEBALANCE'); - } - if (!increaseBaseBalance(_to, _value)) { - revert('ERR_TX_INCREASEBALANCE'); - } - period = actualPeriod(); - if (_value > 0 && accountPeriod(_from) != period) { - registerAccountPeriod(_from, period); - } - return true; - } // ERC20, triggers tax and/or redistribution function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { uint256 baseValue; bool result; - applyTax(); + applyDemurrage(); + changePeriod(); applyRedistributionOnAccount(msg.sender); baseValue = toBaseAmount(_value); @@ -345,16 +426,17 @@ contract RedistributedDemurrageToken { return result; } - // ERC20, triggers tax and/or redistribution - function approve(address _spender, uint256 _value) public returns (bool) { - uint256 baseValue; + // ERC20 transfer backend for transfer, transferFrom + function transferBase(address _from, address _to, uint256 _value) private returns (bool) { + uint256 period; - applyTax(); - applyRedistributionOnAccount(msg.sender); + decreaseBaseBalance(_from, _value); + increaseBaseBalance(_to, _value); - baseValue = toBaseAmount(_value); - allowance[msg.sender][_spender] += baseValue; - emit Approval(msg.sender, _spender, _value); + period = actualPeriod(); + if (_value >= minimumParticipantSpend && accountPeriod(_from) != period && _from != _to) { + registerAccountPeriod(_from, period); + } return true; } }