Add steps option to demurrage cli

python/erc20_demurrage_token/token.py

@@ -38,15 +38,6 @@ class DemurrageTokenSettings:
         self.sink_address = None
 
 
-    def __str__(self):
-        return 'name {} demurrage level {} period minutes {} sink address {}'.format(
-                self.name,
-                self.demurrage_level,
-                self.period_minutes,
-                self.sink_address,
-                )
-
-
 class DemurrageToken(ERC20):
 
     __abi = {}
@@ -155,33 +146,6 @@ class DemurrageToken(ERC20):
         return tx
 
 
-    def burn(self, contract_address, sender_address, value, tx_format=TxFormat.JSONRPC):
-        enc = ABIContractEncoder()
-        enc.method('burn')
-        enc.typ(ABIContractType.UINT256)
-        enc.uint256(value)
-        data = enc.get()
-        tx = self.template(sender_address, contract_address, use_nonce=True)
-        tx = self.set_code(tx, data)
-        tx = self.finalize(tx, tx_format)
-        return tx
-
-
-    def total_burned(self, contract_address, sender_address=ZERO_ADDRESS, id_generator=None):
-        j = JSONRPCRequest(id_generator)
-        o = j.template()
-        o['method'] = 'eth_call'
-        enc = ABIContractEncoder()
-        enc.method('totalBurned')
-        data = add_0x(enc.get())
-        tx = self.template(sender_address, contract_address)
-        tx = self.set_code(tx, data)
-        o['params'].append(self.normalize(tx))
-        o['params'].append('latest')
-        o = j.finalize(o)
-        return o
-
-
     def to_base_amount(self, contract_address, value, sender_address=ZERO_ADDRESS, id_generator=None):
         j = JSONRPCRequest(id_generator)
         o = j.template()
@@ -553,7 +517,6 @@ class DemurrageToken(ERC20):
     def parse_supply_cap(self, v):
         return abi_decode_single(ABIContractType.UINT256, v)
 
-
     @classmethod
     def parse_grow_by(self, v):
         return abi_decode_single(ABIContractType.UINT256, v)
@@ -577,8 +540,3 @@ class DemurrageToken(ERC20):
     @classmethod
     def parse_resolution_factor(self, v):
         return abi_decode_single(ABIContractType.UINT256, v)
-
-
-    @classmethod
-    def parse_total_burned(self, v):
-        return abi_decode_single(ABIContractType.UINT256, v)

python/erc20_demurrage_token/unittest/base.py

@@ -32,19 +32,18 @@ PERIOD = 10
 
 class TestTokenDeploy:
 
-    def __init__(self, rpc, token_symbol='FOO', token_name='Foo Token', sink_address=ZERO_ADDRESS, supply=10**12, tax_level=TAX_LEVEL, period=PERIOD):
-        self.tax_level = tax_level
-        self.period_seconds = period * 60
+    def __init__(self, rpc, token_symbol='FOO', token_name='Foo Token', sink_address=ZERO_ADDRESS, supply=10**12):
+        self.tax_level = TAX_LEVEL
+        self.period_seconds = PERIOD * 60
 
         self.settings = DemurrageTokenSettings()
         self.settings.name = token_name
         self.settings.symbol = token_symbol
         self.settings.decimals = 6
-        self.settings.demurrage_level = tax_level * (10 ** 32)
-        self.settings.period_minutes = period
+        self.settings.demurrage_level = TAX_LEVEL * (10 ** 32)
+        self.settings.period_minutes = PERIOD
         self.settings.sink_address = sink_address
         self.sink_address = self.settings.sink_address
-        logg.debug('using demurrage token settings: {}'.format(self.settings))
 
         o = block_latest()
         self.start_block = rpc.do(o)
@@ -102,12 +101,7 @@ class TestDemurrage(EthTesterCase):
 #        self.start_time = token_deploy.start_time
 #        self.default_supply = self.default_supply
 #        self.default_supply_cap = self.default_supply_cap
-        period = PERIOD
-        try:
-            period = getattr(self, 'period')
-        except AttributeError as e:
-            pass
-        self.deployer = TestTokenDeploy(self.rpc, period=period)
+        self.deployer = TestTokenDeploy(self.rpc)
         self.default_supply = self.deployer.default_supply
         self.default_supply_cap = self.deployer.default_supply_cap
         self.start_block = None
@@ -209,11 +203,10 @@ class TestDemurrageCap(TestDemurrage):
 class TestDemurrageUnit(TestDemurrage):
 
     def setUp(self):
-        self.period = 1
-        self.period_seconds = self.period * 60
-        self.tax_level = TAX_LEVEL
+        super(TestDemurrage, self).setUp()
 
-        super(TestDemurrageUnit, self).setUp()
+        self.tax_level = 50
+        self.period_seconds = 60
 
         nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
         self.settings = DemurrageTokenSettings()

python/requirements.txt

@@ -1,3 +1,3 @@
-chainlib-eth~=0.4.6
-eth-erc20~=0.5.1
+chainlib-eth>=0.1.0,<0.2.0
+eth-erc20~=0.3.0
 funga-eth~=0.6.0

python/run_tests.sh

@@ -6,8 +6,7 @@ set -e
 export PYTHONPATH=.
 
 #modes=(MultiNocap MultiCap SingleCap SingleNocap)
-#modes=(SingleCap SingleNocap) # other contracts need to be updted
-modes=(SingleNocap) # other contracts need to be updted
+modes=(SingleCap SingleNocap) # other contracts need to be updted
 for m in ${modes[@]}; do
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_basic.py
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_growth.py
@@ -15,20 +14,13 @@ for m in ${modes[@]}; do
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_single.py
 done
 
-#modes=(SingleCap) # other contracts need to be updted
-modes=()
+modes=(SingleCap) # other contracts need to be updted
 for m in ${modes[@]}; do
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_period.py
+#	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_redistribution_unit.py
 done
 
-modes=(SingleNocap) # other contracts need to be updted
-for m in ${modes[@]}; do
-	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_redistribution_unit.py
-	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_redistribution_single.py
-done
-
-#modes=(MultiCap SingleCap)
-modes=()
+modes=(MultiCap SingleCap)
 for m in ${modes[@]}; do
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_cap.py
 done

python/tests/test_burn.py

@@ -1,195 +0,0 @@
-# standard imports
-import os
-import unittest
-import json
-import logging
-import datetime
-
-# external imports
-from chainlib.eth.constant import ZERO_ADDRESS
-from chainlib.eth.nonce import RPCNonceOracle
-from chainlib.eth.tx import receipt
-from chainlib.eth.block import (
-        block_latest,
-        block_by_number,
-    )
-
-# local imports
-from erc20_demurrage_token import DemurrageToken
-
-# test imports
-from erc20_demurrage_token.unittest.base import TestDemurrageDefault
-
-logging.basicConfig(level=logging.DEBUG)
-logg = logging.getLogger()
-
-testdir = os.path.dirname(__file__)
-
-
-class TestBurn(TestDemurrageDefault):
-
-    def test_burn_basic(self):
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[1], 1000000)
-        r = self.rpc.do(o)
-
-        nonce_oracle = RPCNonceOracle(self.accounts[1], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-        (tx_hash, o) = c.burn(self.address, self.accounts[1], 600000)
-        r = self.rpc.do(o)
-        o = receipt(tx_hash)
-        r = self.rpc.do(o)
-        self.assertEqual(r['status'], 0)
-
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-        (tx_hash, o) = c.add_minter(self.address, self.accounts[0], self.accounts[1])
-        r = self.rpc.do(o)
-
-        nonce_oracle = RPCNonceOracle(self.accounts[1], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-        (tx_hash, o) = c.burn(self.address, self.accounts[1], 600000)
-        r = self.rpc.do(o)
-        o = receipt(tx_hash)
-        r = self.rpc.do(o)
-        self.assertEqual(r['status'], 1)
-
-        o = c.total_supply(self.address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        new_supply = c.parse_total_supply(r)
-        self.assertEqual(new_supply, 400000)
-
-        o = c.total_burned(self.address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        burned = c.parse_total_burned(r)
-        self.assertEqual(burned, 600000)
-
-
-    def test_burned_redistribution(self):
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[0], 1000000000)
-        r = self.rpc.do(o)
-
-        (tx_hash, o) = c.burn(self.address, self.accounts[0], 500000000)
-        r = self.rpc.do(o)
-
-        (tx_hash, o) = c.transfer(self.address, self.accounts[0], self.sink_address, 500000000)
-        r = self.rpc.do(o)
-
-        self.backend.time_travel(self.start_time + self.period_seconds)
-
-        o = c.balance(self.address, self.sink_address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        bal = c.parse_balance(r)
-        self.assertEqual(bal, 416873881) # 9 periods demurrage
-
-        (tx_hash, o) = c.change_period(self.address, self.accounts[0])
-        r = self.rpc.do(o)
-        o = receipt(tx_hash)
-        r = self.rpc.do(o)
-        self.assertEqual(r['status'], 1)
-
-        o = c.total_supply(self.address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        new_supply = c.parse_total_supply(r)
-        self.assertEqual(new_supply, 500000000)
-
-        o = c.balance(self.address, self.sink_address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        bal = c.parse_balance(r)
-        self.assert_within_lower(bal, 500000000, 0.0025)
-
-        self.backend.time_travel(self.start_time + (self.period_seconds * 2))
-
-        (tx_hash, o) = c.change_period(self.address, self.accounts[0])
-        r = self.rpc.do(o)
-        o = receipt(tx_hash)
-        r = self.rpc.do(o)
-        self.assertEqual(r['status'], 1)
-
-        o = c.total_supply(self.address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        new_supply = c.parse_total_supply(r)
-        self.assertEqual(new_supply, 500000000)
-
-        # if we don't burn anything more it should be the same 
-        o = c.balance(self.address, self.sink_address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        bal = c.parse_balance(r)
-        self.assert_within_lower(bal, 500000000, 0.0025)
-
-
-
-    def test_burned_other_redistribution(self):
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[0], 1000000000)
-        r = self.rpc.do(o)
-
-        (tx_hash, o) = c.burn(self.address, self.accounts[0], 500000000)
-        r = self.rpc.do(o)
-
-        (tx_hash, o) = c.transfer(self.address, self.accounts[0], self.accounts[1], 500000000)
-        r = self.rpc.do(o)
-
-        self.backend.time_travel(self.start_time + self.period_seconds)
-
-        o = c.balance(self.address, self.accounts[1], sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        bal = c.parse_balance(r)
-        self.assertEqual(bal, 416873881) # 9 periods demurrage
-
-        (tx_hash, o) = c.change_period(self.address, self.accounts[0])
-        r = self.rpc.do(o)
-        o = receipt(tx_hash)
-        r = self.rpc.do(o)
-        self.assertEqual(r['status'], 1)
-
-        o = c.total_supply(self.address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        new_supply = c.parse_total_supply(r)
-        self.assertEqual(new_supply, 500000000)
-
-        o = c.balance(self.address, self.accounts[1], sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        bal = c.parse_balance(r)
-        self.assertEqual(bal, 408536403) # 9 periods demurrage
-
-        o = c.balance(self.address, self.sink_address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        sink_bal = c.parse_balance(r)
-        self.assert_within_lower(sink_bal, 500000000 - 408536403, 0.09) # TODO is this ok variance, 1.0 is ppm?
-
-        self.backend.time_travel(self.start_time + (self.period_seconds * 2))
-
-        (tx_hash, o) = c.change_period(self.address, self.accounts[0])
-        r = self.rpc.do(o)
-        o = receipt(tx_hash)
-        r = self.rpc.do(o)
-        self.assertEqual(r['status'], 1)
-
-        o = c.total_supply(self.address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        new_supply = c.parse_total_supply(r)
-        self.assertEqual(new_supply, 500000000)
-
-        o = c.balance(self.address, self.accounts[1], sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        next_bal = c.parse_balance(r)
-        self.assertEqual(next_bal, 333803985) # 9 periods demurrage
-
-        o = c.balance(self.address, self.sink_address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        prev_sink_bal = sink_bal
-        bal = prev_sink_bal + (bal - next_bal)
-        sink_bal = c.parse_balance(r)
-        self.assert_within_lower(sink_bal, bal, 0.09) # TODO is this ok variance, 1.0 is ppm?
-
-
-if __name__ == '__main__':
-    unittest.main()

python/tests/test_redistribution.py

@@ -31,8 +31,6 @@ testdir = os.path.dirname(__file__)
 
 class TestRedistribution(TestDemurrageDefault):
 
-
-
     def test_whole_is_parts(self):
         nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
         c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)

python/tests/test_redistribution_single.py

@@ -1,185 +0,0 @@
-# standard imports
-import os
-import unittest
-import json
-import logging
-
-# external imports
-from chainlib.eth.constant import ZERO_ADDRESS
-from chainlib.eth.nonce import RPCNonceOracle
-from chainlib.eth.tx import receipt
-from chainlib.eth.block import (
-        block_latest,
-        block_by_number,
-        )
-from chainlib.eth.address import to_checksum_address
-from hexathon import (
-        strip_0x,
-        add_0x,
-        )
-
-# local imports
-from erc20_demurrage_token import DemurrageToken
-
-# test imports
-from erc20_demurrage_token.unittest.base import TestDemurrageDefault
-
-logging.basicConfig(level=logging.DEBUG)
-logg = logging.getLogger()
-
-testdir = os.path.dirname(__file__)
-
-class TestRedistribution(TestDemurrageDefault):
-
-
-    def test_redistribution_periods(self):
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        demurrage = (1 - (self.tax_level / 1000000)) * (10**28)
-        supply = self.default_supply
-
-        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[0], supply)
-        self.rpc.do(o)
-
-        for i in range(1, 10):
-            logg.debug('execute time travel to period {}'.format(i))
-            self.backend.time_travel(self.start_time + (self.period_seconds * i))
-            (tx_hash, o) = c.change_period(self.address, self.accounts[0])
-            self.rpc.do(o)
-            o = receipt(tx_hash)
-            r = self.rpc.do(o)
-            self.assertEqual(r['status'], 1)
-
-            o = c.redistributions(self.address, i, sender_address=self.accounts[0])
-            redistribution = self.rpc.do(o)
-
-            o = c.to_redistribution_demurrage_modifier(self.address, redistribution, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            demurrage = c.parse_to_redistribution_item(r)
-
-            o = c.redistributions(self.address, i-1, sender_address=self.accounts[0])
-            redistribution = self.rpc.do(o)
-
-            o = c.to_redistribution_demurrage_modifier(self.address, redistribution, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            demurrage_previous = c.parse_to_redistribution_item(r)
-
-            o = c.balance_of(self.address, self.sink_address, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            balance_sink = c.parse_balance(r)
-
-            o = c.balance_of(self.address, self.accounts[0], sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            balance_minter = c.parse_balance(r)
-
-            logg.debug('testing sink {} mint {} adds up to supply {} with demurrage between {} and {}'.format(balance_sink, balance_minter, supply, demurrage_previous, demurrage))
-
-            self.assert_within_lower(balance_minter + balance_sink, supply, 0.001)
-
-
-    def test_redistribution_catchup_periods(self):
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        demurrage = (1 - (self.tax_level / 1000000)) * (10**28)
-        supply = self.default_supply
-
-        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[0], supply)
-        self.rpc.do(o)
-
-        self.backend.time_travel(self.start_time + (self.period_seconds * 10))
-
-        for i in range(1, 11):
-            logg.debug('checking period {}'.format(i))
-
-            (tx_hash, o) = c.change_period(self.address, self.accounts[0])
-            self.rpc.do(o)
-            o = receipt(tx_hash)
-            r = self.rpc.do(o)
-            self.assertEqual(r['status'], 1)
-
-        i = 10
-        o = c.redistributions(self.address, i, sender_address=self.accounts[0])
-        redistribution = self.rpc.do(o)
-
-        o = c.to_redistribution_demurrage_modifier(self.address, redistribution, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        demurrage = c.parse_to_redistribution_item(r)
-
-        o = c.redistributions(self.address, i-1, sender_address=self.accounts[0])
-        redistribution = self.rpc.do(o)
-
-        o = c.to_redistribution_demurrage_modifier(self.address, redistribution, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        demurrage_previous = c.parse_to_redistribution_item(r)
-
-        o = c.balance_of(self.address, self.sink_address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        balance_sink = c.parse_balance(r)
-
-        o = c.balance_of(self.address, self.accounts[0], sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        balance_minter = c.parse_balance(r)
-
-        logg.debug('testing sink {} mint {} adds up to supply {} with demurrage between {} and {}'.format(balance_sink, balance_minter, supply, demurrage_previous, demurrage))
-
-        self.assert_within_lower(balance_minter + balance_sink, supply, 0.001)
-
-
-#    def test_redistribution_boundaries(self):
-#        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-#        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-#
-#        demurrage = (1 - (self.tax_level / 1000000)) * (10**28)
-#        supply = self.default_supply
-#
-#        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[0], supply)
-#        self.rpc.do(o)
-#
-#        o = c.balance_of(self.address, self.sink_address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance(r)
-#        logg.debug('balance before {} supply {}'.format(balance, supply))
-#
-#        self.backend.time_travel(self.start_time + self.period_seconds)
-#        (tx_hash, o) = c.change_period(self.address, self.accounts[0])
-#        r = self.rpc.do(o)
-#
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#        o = c.redistributions(self.address, 1, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        oo = c.to_redistribution_supply(self.address, r, sender_address=self.accounts[0])
-#        rr = self.rpc.do(oo)
-#        oo = c.to_redistribution_demurrage_modifier(self.address, r, sender_address=self.accounts[0])
-#        rr = self.rpc.do(oo)
-#
-#        o = c.balance_of(self.address, self.sink_address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance(r)
-#
-#        self.backend.time_travel(self.start_time + self.period_seconds * 2 + 1)
-#        (tx_hash, o) = c.change_period(self.address, self.accounts[0])
-#        r = self.rpc.do(o)
-#
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#        o = c.redistributions(self.address, 2, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        oo = c.to_redistribution_supply(self.address, r, sender_address=self.accounts[0])
-#        rr = self.rpc.do(oo)
-#        oo = c.to_redistribution_demurrage_modifier(self.address, r, sender_address=self.accounts[0])
-#        rr = self.rpc.do(oo)
-#
-#        o = c.balance_of(self.address, self.sink_address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance(r)
-
-
-if __name__ == '__main__':
-    unittest.main()

python/tests/test_redistribution_unit.py

@@ -31,12 +31,12 @@ testdir = os.path.dirname(__file__)
 
 class TestRedistribution(TestDemurrageUnit):
 
-
     # TODO: move to "pure" test file when getdistribution is implemented in all contracts
-    def test_distribution_direct(self):
+    def test_distribution(self):
         nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
         c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
 
+        #demurrage = (1 - (self.tax_level / 1000000)) * (10**38)
         demurrage = (1 - (self.tax_level / 1000000)) * (10**28)
         supply = self.default_supply
 
@@ -51,23 +51,21 @@ class TestRedistribution(TestDemurrageUnit):
         nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
         c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
 
-        demurrage = (1 - (self.tax_level / 100000)) * (10**28)
-
-        logg.debug('demurrage {}'.format(demurrage))
+        #demurrage = (1 - (self.tax_level / 1000000)) * (10**38)
+        demurrage = (1 - (self.tax_level / 1000000)) * (10**28)
         supply = self.default_supply
 
-        o = c.to_redistribution(self.address, 0, demurrage, supply, 2, sender_address=self.accounts[0])
+        o = c.to_redistribution(self.address, 0, demurrage, supply, 1, sender_address=self.accounts[0])
         redistribution = self.rpc.do(o)
 
         o = c.get_distribution_from_redistribution(self.address, redistribution, self.accounts[0])
         r = self.rpc.do(o)
         distribution = c.parse_get_distribution(r)
-        expected_distribution = (self.default_supply * self.tax_level) / 100000
-        logg.debug('distribution {} supply {}'.format(distribution, self.default_supply))
+        expected_distribution = self.default_supply * (self.tax_level / 1000000)
         self.assert_within_lower(distribution, expected_distribution, 1000)
 
 
-    def test_single_step_basic(self):
+    def test_single_step(self):
         nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
         c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
 
@@ -83,12 +81,6 @@ class TestRedistribution(TestDemurrageUnit):
 
         expected_balance = int(mint_amount - ((self.tax_level / 1000000) * mint_amount))
 
-        o = c.balance_of(self.address, ZERO_ADDRESS, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        balance = c.parse_balance(r)
-
-        logg.debug('balance {}'.format(balance))
-
         o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
         r = self.rpc.do(o)
         balance = c.parse_balance(r)
@@ -183,6 +175,9 @@ class TestRedistribution(TestDemurrageUnit):
         o = c.to_redistribution_demurrage_modifier(self.address, redistribution, sender_address=self.accounts[0])
         r = self.rpc.do(o)
         demurrage = c.parse_to_redistribution_item(r)
+#        o = c.demurrage_amount(self.address, sender_address=self.accounts[0])
+#        r = self.rpc.do(o)
+#        demurrage = c.parse_demurrage_amount(r)
         logg.debug('\nrediistribution {}\ndemurrage {}\nsupply {}'.format(redistribution, demurrage, supply))
 
         expected_balance = int(supply * (self.tax_level / 1000000))

solidity/DemurrageTokenSingleNocap.sol

@@ -1,6 +1,7 @@
 pragma solidity > 0.6.11;
 
 // SPDX-License-Identifier: GPL-3.0-or-later
+
 contract DemurrageTokenSingleCap {
 
 	// Redistribution bit field, with associated shifts and masks
@@ -19,6 +20,8 @@ contract DemurrageTokenSingleCap {
 	// Cached demurrage amount, ppm with 38 digit resolution
 	uint128 public demurrageAmount;
 
+	// Cached demurrage period; the period for which demurrageAmount was calculated
+	//uint128 public demurragePeriod;
 	// Cached demurrage timestamp; the timestamp for which demurrageAmount was last calculated
 	uint256 public demurrageTimestamp;
 
@@ -37,17 +40,10 @@ contract DemurrageTokenSingleCap {
 	uint256 public decimals;
 
 	// Implements ERC20
-	//uint256 public totalSupply;
-	uint256 supply;
+	uint256 public totalSupply;
 
-	// Last executed period
-	uint256 public lastPeriod;
-
-	// Last sink redistribution amount
-	uint256 public totalSink;
-
-	// Value of burnt tokens (burnt tokens do not decay)
-	uint256 public burned;
+	// Minimum amount of (demurraged) tokens an account must spend to participate in redistribution for a particular period
+	uint256 public minimumParticipantSpend;
 
 	// 128 bit resolution of the demurrage divisor
 	// (this constant x 1000000 is contained within 128 bits)
@@ -75,7 +71,7 @@ contract DemurrageTokenSingleCap {
 	mapping (address => mapping (address => uint256 ) ) allowance; // holder -> spender -> amount (amount is subject to demurrage)
 
 	// Address to send unallocated redistribution tokens
-	address public sinkAddress; 
+	address sinkAddress; 
 
 	// Implements ERC20
 	event Transfer(address indexed _from, address indexed _to, uint256 _value);
@@ -98,9 +94,6 @@ contract DemurrageTokenSingleCap {
 	// Temporary event used in development, will be removed on prod
 	event Debug(bytes32 _foo);
 
-	// Emitted when tokens are burned
-	event Burn(address indexed _burner, uint256 _value);
-
 	// EIP173
 	event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); // EIP173
 
@@ -118,13 +111,17 @@ contract DemurrageTokenSingleCap {
 		demurrageTimestamp = block.timestamp;
 		periodStart = demurrageTimestamp;
 		periodDuration = _periodMinutes * 60;
-		demurrageAmount = uint128(nanoDivider) * 100;
+		//demurrageAmount = 100000000000000000000000000000000000000 - _taxLevelMinute; // Represents 38 decimal places, same as resolutionFactor
+		//demurrageAmount = 100000000000000000000000000000000000000;
+		demurrageAmount = 10000000000000000000000000000;
+		//demurragePeriod = 1;
 		taxLevel = _taxLevelMinute; // Represents 38 decimal places
 		bytes32 initialRedistribution = toRedistribution(0, demurrageAmount, 0, 1);
 		redistributions.push(initialRedistribution);
 
 		// Misc settings
 		sinkAddress = _defaultSinkAddress;
+		minimumParticipantSpend = 10 ** uint256(_decimals);
 	}
 
 
@@ -156,8 +153,10 @@ contract DemurrageTokenSingleCap {
 
 		baseBalance = baseBalanceOf(_account);
 
+		//periodCount = actualPeriod() - demurragePeriod; 
 		periodCount = getMinutesDelta(demurrageTimestamp);
 
+		//currentDemurragedAmount = uint128(decayBy(demurrageAmount, periodCount));
 		currentDemurragedAmount = uint128(decayBy(demurrageAmount * 10000000000, periodCount));
 
 		return (baseBalance * currentDemurragedAmount) / (nanoDivider * 1000000000000);
@@ -212,7 +211,7 @@ contract DemurrageTokenSingleCap {
 
 		changePeriod();
 		baseAmount = toBaseAmount(_amount);
-		supply += _amount;
+		totalSupply += _amount;
 		increaseBaseBalance(_beneficiary, baseAmount);
 		emit Mint(msg.sender, _beneficiary, _amount);
 		saveRedistributionSupply();
@@ -255,7 +254,8 @@ contract DemurrageTokenSingleCap {
 		uint256 currentRedistribution;
 		uint256 grownSupply;
 
-		grownSupply = totalSupply();
+		//grownSupply = growBy(totalSupply, 1);
+		grownSupply = totalSupply;
 		currentRedistribution = uint256(redistributions[redistributions.length-1]);
 		currentRedistribution &= (~maskRedistributionValue);
 		currentRedistribution |= (grownSupply << shiftRedistributionValue);
@@ -274,7 +274,7 @@ contract DemurrageTokenSingleCap {
 		bytes32 lastRedistribution;
 		uint256 currentPeriod;
 
-		lastRedistribution =  redistributions[lastPeriod];
+		lastRedistribution =  redistributions[redistributions.length-1];
 		currentPeriod = this.actualPeriod();
 		if (currentPeriod <= toRedistributionPeriod(lastRedistribution)) {
 			return bytes32(0x00);
@@ -285,7 +285,8 @@ contract DemurrageTokenSingleCap {
 	function getDistribution(uint256 _supply, uint256 _demurrageAmount) public view returns (uint256) {
 		uint256 difference;
 
-		difference = _supply * (resolutionFactor - (_demurrageAmount * 10000000000));
+		//difference = _supply * (resolutionFactor - _demurrageAmount); //(nanoDivider - ((resolutionFactor - _demurrageAmount) / nanoDivider));
+		difference = _supply * (resolutionFactor - (_demurrageAmount * 10000000000)); //(nanoDivider - ((resolutionFactor - _demurrageAmount) / nanoDivider));
 		return difference / resolutionFactor;
 	}
 
@@ -301,13 +302,9 @@ contract DemurrageTokenSingleCap {
 	// Returns the amount sent to the sink address
 	function applyDefaultRedistribution(bytes32 _redistribution) private returns (uint256) {
 		uint256 unit;
-		uint256 baseUnit;
 	
 		unit = getDistributionFromRedistribution(_redistribution);	
-		baseUnit = toBaseAmount(unit) - totalSink;
-		increaseBaseBalance(sinkAddress, baseUnit);
-		lastPeriod += 1;
-		totalSink += baseUnit;
+		increaseBaseBalance(sinkAddress, toBaseAmount(unit));
 		return unit;
 	}
 
@@ -322,9 +319,13 @@ contract DemurrageTokenSingleCap {
 	}
 
 	function applyDemurrageLimited(uint256 _rounds) public returns (bool) {
+		//uint128 epochPeriodCount;
 		uint256 periodCount;
 		uint256 lastDemurrageAmount;
 
+		//epochPeriodCount = actualPeriod();
+		//periodCount = epochPeriodCount - demurragePeriod;
+
 		periodCount = getMinutesDelta(demurrageTimestamp);
 		if (periodCount == 0) {
 			return false;
@@ -384,7 +385,7 @@ contract DemurrageTokenSingleCap {
 			nextRedistributionDemurrage = currentDemurrageAmount;
 		}
 		
-		nextRedistribution = toRedistribution(0, nextRedistributionDemurrage, totalSupply(), nextPeriod);
+		nextRedistribution = toRedistribution(0, nextRedistributionDemurrage, totalSupply, nextPeriod);
 		redistributions.push(nextRedistribution);
 
 		applyDefaultRedistribution(nextRedistribution);
@@ -422,6 +423,7 @@ contract DemurrageTokenSingleCap {
 
 	// Inflates the given amount according to the current demurrage modifier
 	function toBaseAmount(uint256 _value) public view returns (uint256) {
+		//return (_value * resolutionFactor) / demurrageAmount;
 		return (_value * resolutionFactor) / (demurrageAmount * 10000000000);
 	}
 
@@ -472,6 +474,7 @@ contract DemurrageTokenSingleCap {
 		decreaseBaseBalance(_from, _value);
 		increaseBaseBalance(_to, _value);
 
+		//period = actualPeriod();
 		return true;
 	}
 
@@ -492,28 +495,6 @@ contract DemurrageTokenSingleCap {
 		emit OwnershipTransferred(oldOwner, owner);
 	}
 
-	// Explicitly and irretrievably burn tokens
-	function burn(uint256 _value) public {
-		require(minter[msg.sender]);
-		require(_value <= account[msg.sender]);
-		uint256 _delta = toBaseAmount(_value);
-
-		applyDemurrage();
-		decreaseBaseBalance(msg.sender, _delta);
-		burned += _value;
-		emit Burn(msg.sender, _value);
-	}
-
-	// Implements ERC20
-	function totalSupply() public view returns (uint256) {
-		return supply - burned;
-	}
-
-	// Return total number of burned tokens
-	function totalBurned() public view returns (uint256) {
-		return burned;
-	}
-
 	// Implements EIP165
 	function supportsInterface(bytes4 _sum) public pure returns (bool) {
 		if (_sum == 0xc6bb4b70) { // ERC20