Remove commented contract code, makefile single nocap only

CAVEAT

@@ -1,5 +0,0 @@
-The contract is intended for slow rates of decay (e.g. 2% per month). Very high levels of decay (2% per minute) will lead to overflows, and will need a more flexible implementation to support it.
-
-The contract is written with frequent usage in mind. If used for tokens with low usage freqency (e.g. several days idle), it is recommended to run a continuous process triggering the changePeriod() contract call, to reduce the amount of exponential calculation the application of demurrage will trigger.
-
-When changing the period, the supply for the consecutive period will be taken at the time of code execution, and thus not necessarily at the time when the redistribution period threshold was crossed. 

ROADMAP

@@ -1,8 +0,0 @@
-- 0.1.3
-	* Snapshot supply for crossed redistribution thresholds before minting new tokens.
-- 0.1.4
-	* Implement natural logarithm 
-- 0.1.5
-	* Port changes from SingleNocap to SingleCap
-- 0.2.0
-	* Make decay resolutions configurable, to support high levels of decay.

VERSION

@@ -1 +0,0 @@
-0.1.2

python/CHANGELOG

@@ -1,9 +1,3 @@
-- 0.2.0
-	* Add token burn function
-	* Fix gas leak when calculating decay on period change
-	* Remove all but SingleNocap contract in make install
-	* Make approve explicitly set value
-	* Add increaseAllowance and decreaseAllowance methods
 - 0.1.1
 	* Settable demurrage steps for apply demurrage cli tool
 - 0.1.0

python/erc20_demurrage_token/runnable/apply.py

@@ -16,7 +16,17 @@ import math
 
 # external imports
 import confini
-import chainlib.eth.cli
+from funga.eth.signer import EIP155Signer
+from funga.eth.keystore.dict import DictKeystore
+from chainlib.chain import ChainSpec
+from chainlib.eth.nonce import (
+        RPCNonceOracle,
+        OverrideNonceOracle,
+        )
+from chainlib.eth.gas import (
+        RPCGasOracle,
+        OverrideGasOracle,
+        )
 from chainlib.eth.block import (
         block_latest,
         block_by_number,
@@ -25,20 +35,8 @@ from chainlib.eth.block import (
 from chainlib.eth.connection import EthHTTPConnection
 from chainlib.eth.tx import receipt
 from chainlib.eth.constant import ZERO_ADDRESS
-from hexathon import to_int as hex_to_int
 import chainlib.eth.cli
-from chainlib.eth.settings import process_settings
-from chainlib.settings import ChainSettings
-from chainlib.eth.cli.arg import (
-        Arg,
-        ArgFlag,
-        process_args,
-        )
-from chainlib.eth.cli.config import (
-        Config,
-        process_config,
-        )
-from chainlib.eth.cli.log import process_log
+from hexathon import to_int as hex_to_int
 
 # local imports
 import erc20_demurrage_token
@@ -47,38 +45,32 @@ from erc20_demurrage_token import (
         DemurrageTokenSettings,
         )
 
+logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
 
+script_dir = os.path.dirname(__file__)
+data_dir = os.path.join(script_dir, '..', 'data')
 
-def process_config_local(config, arg, args, flags):
-    config.add(args.steps, '_STEPS', False)
-    return config
+config_dir = os.path.join(data_dir, 'config')
 
-
-arg_flags = ArgFlag()
-arg = Arg(arg_flags)
-flags = arg_flags.STD_WRITE | arg_flags.EXEC | arg_flags.WALLET
-
-argparser = chainlib.eth.cli.ArgumentParser()
-argparser = process_args(argparser, arg, flags)
+arg_flags = chainlib.eth.cli.argflag_std_write | chainlib.eth.cli.Flag.EXEC
+argparser = chainlib.eth.cli.ArgumentParser(arg_flags)
 argparser.add_argument('--steps', type=int, default=0, help='Max demurrage steps to apply per round')
 args = argparser.parse_args()
-
-logg = process_log(args, logg)
-
-config = Config()
-config = process_config(config, arg, args, flags)
-config = process_config_local(config, arg, args, flags)
+config = chainlib.eth.cli.Config.from_args(args, arg_flags, default_fee_limit=DemurrageToken.gas(), base_config_dir=config_dir)
+config.add(args.steps, '_STEPS', False)
 logg.debug('config loaded:\n{}'.format(config))
 
-settings = ChainSettings()
-settings = process_settings(settings, config)
-logg.debug('settings loaded:\n{}'.format(settings))
+wallet = chainlib.eth.cli.Wallet()
+wallet.from_config(config)
+
+rpc = chainlib.eth.cli.Rpc(wallet=wallet)
+conn = rpc.connect_by_config(config)
+
+chain_spec = ChainSpec.from_chain_str(config.get('CHAIN_SPEC'))
 
 
 def main():
-    chain_spec = settings.get('CHAIN_SPEC')
-    conn = settings.get('CONN')
     o = block_latest()
     r = conn.do(o)
  
@@ -95,9 +87,9 @@ def main():
     block_start_timestamp = block_start.timestamp
     block_start_datetime = datetime.datetime.fromtimestamp(block_start_timestamp)
 
-    gas_oracle = settings.get('FEE_ORACLE')
+    gas_oracle = rpc.get_gas_oracle()
     c = DemurrageToken(chain_spec, gas_oracle=gas_oracle)
-    o = c.demurrage_timestamp(settings.get('EXEC'))
+    o = c.demurrage_timestamp(config.get('_EXEC_ADDRESS'))
     r = conn.do(o)
 
     demurrage_timestamp = None
@@ -128,17 +120,17 @@ def main():
 
     last_tx_hash = None
     for i in range(rounds):
-        signer = settings.get('SIGNER')
-        signer_address = settings.get('SENDER_ADDRESS')
+        signer = rpc.get_signer()
+        signer_address = rpc.get_sender_address()
 
-        nonce_oracle = settings.get('NONCE_ORACLE')
+        nonce_oracle = rpc.get_nonce_oracle()
 
         c = DemurrageToken(chain_spec, signer=signer, gas_oracle=gas_oracle, nonce_oracle=nonce_oracle)
         (tx_hash_hex, o) = c.apply_demurrage(config.get('_EXEC_ADDRESS'), signer_address, limit=config.get('_STEPS'))
-        if settings.get('RPC_SEND'):
+        if config.get('_RPC_SEND'):
             print(tx_hash_hex)
             conn.do(o)
-            if config.true('_WAIT_ALL') or (i == rounds - 1 and config.true('_WAIT')):
+            if config.get('_WAIT_ALL') or (i == rounds - 1 and config.get('_WAIT')):
                 r = conn.wait(tx_hash_hex)
                 if r['status'] == 0:
                     sys.stderr.write('EVM revert while deploying contract. Wish I had more to tell you')

python/erc20_demurrage_token/runnable/deploy.py

@@ -14,22 +14,21 @@ import logging
 
 # external imports
 import confini
+from funga.eth.signer import EIP155Signer
+from funga.eth.keystore.dict import DictKeystore
+from chainlib.chain import ChainSpec
+from chainlib.eth.nonce import (
+        RPCNonceOracle,
+        OverrideNonceOracle,
+        )
+from chainlib.eth.gas import (
+        RPCGasOracle,
+        OverrideGasOracle,
+        )
 from chainlib.eth.connection import EthHTTPConnection
 from chainlib.eth.tx import receipt
 from chainlib.eth.constant import ZERO_ADDRESS
 import chainlib.eth.cli
-from chainlib.eth.settings import process_settings
-from chainlib.settings import ChainSettings
-from chainlib.eth.cli.arg import (
-        Arg,
-        ArgFlag,
-        process_args,
-        )
-from chainlib.eth.cli.config import (
-        Config,
-        process_config,
-        )
-from chainlib.eth.cli.log import process_log
 
 # local imports
 import erc20_demurrage_token
@@ -38,75 +37,84 @@ from erc20_demurrage_token import (
         DemurrageTokenSettings,
         )
 
+logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
 
+script_dir = os.path.dirname(__file__)
+data_dir = os.path.join(script_dir, '..', 'data')
 
-def process_config_local(config, arg, args, flags):
-    config.add(args.token_name, 'TOKEN_NAME', False)
-    config.add(args.token_symbol, 'TOKEN_SYMBOL', False)
-    config.add(args.token_decimals, 'TOKEN_DECIMALS', False)
-    config.add(args.sink_address, 'TOKEN_SINK_ADDRESS', False)
-    config.add(args.redistribution_period, 'TOKEN_REDISTRIBUTION_PERIOD', False)
-    config.add(args.demurrage_level, 'TOKEN_DEMURRAGE_LEVEL', False)
-    config.add(0, 'TOKEN_SUPPLY_LIMIT', False)
-    return config
+config_dir = os.path.join(data_dir, 'config')
 
-
-arg_flags = ArgFlag()
-arg = Arg(arg_flags)
-flags = arg_flags.STD_WRITE | arg_flags.EXEC | arg_flags.WALLET
-
-argparser = chainlib.eth.cli.ArgumentParser()
-argparser = process_args(argparser, arg, flags)
+arg_flags = chainlib.eth.cli.argflag_std_write
+argparser = chainlib.eth.cli.ArgumentParser(arg_flags)
 argparser.add_argument('--name', dest='token_name', type=str, help='Token name')
 argparser.add_argument('--symbol', dest='token_symbol', required=True, type=str, help='Token symbol')
 argparser.add_argument('--decimals', dest='token_decimals', type=int, help='Token decimals')
 argparser.add_argument('--sink-address', dest='sink_address', type=str, help='demurrage level,ppm per minute') 
-#argparser.add_argument('--supply-limit', dest='supply_limit', type=int, help='token supply limit (0 = no limit)')
-argparser.add_argument('--redistribution-period', dest='redistribution_period', type=int, help='redistribution period, minutes (0 = deactivate)') # default 10080 = week
-#argparser.add_argument('--multi', action='store_true', help='automatic redistribution')
+argparser.add_argument('--supply-limit', dest='supply_limit', type=int, help='token supply limit (0 = no limit)')
+argparser.add_argument('--redistribution-period', type=int, help='redistribution period, minutes (0 = deactivate)') # default 10080 = week
+argparser.add_argument('--multi', action='store_true', help='automatic redistribution')
 argparser.add_argument('--demurrage-level', dest='demurrage_level', type=int, help='demurrage level, ppm per minute') 
 args = argparser.parse_args()
 
-logg = process_log(args, logg)
+arg_flags = chainlib.eth.cli.argflag_std_write
 
-config = Config()
-config = process_config(config, arg, args, flags)
-config = process_config_local(config, arg, args, flags)
+extra_args = {
+        'redistribution_period': 'TOKEN_REDISTRIBUTION_PERIOD',
+        'demurrage_level': 'TOKEN_DEMURRAGE_LEVEL',
+        'supply_limit': 'TOKEN_SUPPLY_LIMIT',
+        'token_name': 'TOKEN_NAME',
+        'token_symbol': 'TOKEN_SYMBOL',
+        'token_decimals': 'TOKEN_DECIMALS',
+        'sink_address': 'TOKEN_SINK_ADDRESS',
+        'multi': None,
+        }
+config = chainlib.eth.cli.Config.from_args(args, arg_flags, extra_args=extra_args, default_fee_limit=DemurrageToken.gas(), base_config_dir=config_dir)
+
+if not bool(config.get('TOKEN_NAME')):
+    logg.info('token name not set, using symbol {} as name'.format(config.get('TOKEN_SYMBOL')))
+    config.add(config.get('TOKEN_SYMBOL'), 'TOKEN_NAME', True)
+
+if config.get('TOKEN_SUPPLY_LIMIT') == None:
+    config.add(0, 'TOKEN_SUPPLY_LIMIT', True)
+
+if config.get('TOKEN_REDISTRIBUTION_PERIOD') == None:
+    config.add(10800, 'TOKEN_REDISTRIBUTION_PERIOD', True)
 logg.debug('config loaded:\n{}'.format(config))
 
-settings = ChainSettings()
-settings = process_settings(settings, config)
-logg.debug('settings loaded:\n{}'.format(settings))
+wallet = chainlib.eth.cli.Wallet()
+wallet.from_config(config)
 
+rpc = chainlib.eth.cli.Rpc(wallet=wallet)
+conn = rpc.connect_by_config(config)
+
+chain_spec = ChainSpec.from_chain_str(config.get('CHAIN_SPEC'))
 
 def main():
-    chain_spec = settings.get('CHAIN_SPEC')
-    conn = settings.get('CONN')
-    signer = settings.get('SIGNER')
-    signer_address = settings.get('SENDER_ADDRESS')
+    signer = rpc.get_signer()
+    signer_address = rpc.get_sender_address()
 
-    gas_oracle = settings.get('FEE_ORACLE')
-    nonce_oracle = settings.get('NONCE_ORACLE')
+    gas_oracle = rpc.get_gas_oracle()
+    nonce_oracle = rpc.get_nonce_oracle()
 
     c = DemurrageToken(chain_spec, signer=signer, gas_oracle=gas_oracle, nonce_oracle=nonce_oracle)
-    token_settings = DemurrageTokenSettings()
-    token_settings.name = config.get('TOKEN_NAME')
-    token_settings.symbol = config.get('TOKEN_SYMBOL')
-    token_settings.decimals = int(config.get('TOKEN_DECIMALS'))
-    token_settings.demurrage_level = int(config.get('TOKEN_DEMURRAGE_LEVEL'))
-    token_settings.period_minutes = int(config.get('TOKEN_REDISTRIBUTION_PERIOD'))
-    token_settings.sink_address = config.get('TOKEN_SINK_ADDRESS')
+    settings = DemurrageTokenSettings()
+    settings.name = config.get('TOKEN_NAME')
+    settings.symbol = config.get('TOKEN_SYMBOL')
+    settings.decimals = int(config.get('TOKEN_DECIMALS'))
+    settings.demurrage_level = int(config.get('TOKEN_DEMURRAGE_LEVEL'))
+    settings.period_minutes = int(config.get('TOKEN_REDISTRIBUTION_PERIOD'))
+    settings.sink_address = config.get('TOKEN_SINK_ADDRESS')
 
     (tx_hash_hex, o) = c.constructor(
             signer_address,
-            token_settings,
+            settings,
             redistribute=config.true('_MULTI'),
             cap=int(config.get('TOKEN_SUPPLY_LIMIT')),
             )
-    if settings.get('RPC_SEND'):
+    if config.get('_RPC_SEND'):
         conn.do(o)
-        if config.true('_WAIT'):
+        if config.get('_WAIT'):
             r = conn.wait(tx_hash_hex)
             if r['status'] == 0:
                 sys.stderr.write('EVM revert while deploying contract. Wish I had more to tell you')

python/erc20_demurrage_token/token.py

@@ -10,6 +10,7 @@ from chainlib.eth.tx import (
 from chainlib.hash import keccak256_string_to_hex
 from chainlib.eth.contract import (
         ABIContractEncoder,
+        ABIContractDecoder,
         ABIContractType,
         abi_decode_single,
         )
@@ -310,8 +311,11 @@ class DemurrageToken(ERC20):
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('toRedistributionPeriod')
-        enc.typ(ABIContractType.BYTES32)
-        enc.bytes32(redistribution)
+        v = strip_0x(redistribution)
+        enc.typ_literal('(uint32,uint72,uint104)')
+        enc.bytes32(v[:64])
+        enc.bytes32(v[64:128])
+        enc.bytes32(v[128:192])
         data = add_0x(enc.get())
         tx = self.template(sender_address, contract_address)
         tx = self.set_code(tx, data)
@@ -321,22 +325,26 @@ class DemurrageToken(ERC20):
         return o
 
 
-    def to_redistribution_participants(self, contract_address, redistribution, sender_address=ZERO_ADDRESS, id_generator=None):
-        j = JSONRPCRequest(id_generator)
-        o = j.template()
-        o['method'] = 'eth_call'
-        enc = ABIContractEncoder()
-        enc.method('toRedistributionParticipants')
-        enc.typ(ABIContractType.BYTES32)
-        enc.bytes32(redistribution)
-        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_redistribution_participants(self, contract_address, redistribution, sender_address=ZERO_ADDRESS, id_generator=None):
+#        j = JSONRPCRequest(id_generator)
+#        o = j.template()
+#        o['method'] = 'eth_call'
+#        enc = ABIContractEncoder()
+#        enc.method('toRedistributionParticipants')
+#        v = strip_0x(redistribution)
+#        enc.typ_literal('(uint32,uint72,uint104)')
+#        #enc.typ(ABIContractType.BYTES32)
+#        enc.bytes32(v[:64])
+#        enc.bytes32(v[64:128])
+#        enc.bytes32(v[128:192])
+#        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_redistribution_supply(self, contract_address, redistribution, sender_address=ZERO_ADDRESS, id_generator=None):
         j = JSONRPCRequest(id_generator)
@@ -344,8 +352,11 @@ class DemurrageToken(ERC20):
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('toRedistributionSupply')
-        enc.typ(ABIContractType.BYTES32)
-        enc.bytes32(redistribution)
+        v = strip_0x(redistribution)
+        enc.typ_literal('(uint32,uint72,uint104)')
+        enc.bytes32(v[:64])
+        enc.bytes32(v[64:128])
+        enc.bytes32(v[128:192])
         data = add_0x(enc.get())
         tx = self.template(sender_address, contract_address)
         tx = self.set_code(tx, data)
@@ -361,8 +372,11 @@ class DemurrageToken(ERC20):
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('toRedistributionDemurrageModifier')
-        enc.typ(ABIContractType.BYTES32)
-        enc.bytes32(redistribution)
+        v = strip_0x(redistribution)
+        enc.typ_literal('(uint32,uint72,uint104)')
+        enc.bytes32(v[:64])
+        enc.bytes32(v[64:128])
+        enc.bytes32(v[128:192])
         data = add_0x(enc.get())
         tx = self.template(sender_address, contract_address)
         tx = self.set_code(tx, data)
@@ -452,24 +466,24 @@ class DemurrageToken(ERC20):
         return self.call_noarg('supplyCap', contract_address, sender_address=sender_address)
 
 
-    def grow_by(self, contract_address, value, period, sender_address=ZERO_ADDRESS, id_generator=None):
-        j = JSONRPCRequest(id_generator)
-        o = j.template()
-        o['method'] = 'eth_call'
-        enc = ABIContractEncoder()
-        enc.method('growBy')
-        enc.typ(ABIContractType.UINT256)
-        enc.typ(ABIContractType.UINT256)
-        enc.uint256(value)
-        enc.uint256(period)
-        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 grow_by(self, contract_address, value, period, sender_address=ZERO_ADDRESS, id_generator=None):
+#        j = JSONRPCRequest(id_generator)
+#        o = j.template()
+#        o['method'] = 'eth_call'
+#        enc = ABIContractEncoder()
+#        enc.method('growBy')
+#        enc.typ(ABIContractType.UINT256)
+#        enc.typ(ABIContractType.UINT256)
+#        enc.uint256(value)
+#        enc.uint256(period)
+#        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 decay_by(self, contract_address, value, period, sender_address=ZERO_ADDRESS, id_generator=None):
         j = JSONRPCRequest(id_generator)
@@ -515,8 +529,11 @@ class DemurrageToken(ERC20):
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('getDistributionFromRedistribution')
-        enc.typ(ABIContractType.BYTES32)
-        enc.bytes32(redistribution)
+        v = strip_0x(redistribution)
+        enc.typ_literal('(uint32,uint72,uint104)')
+        enc.bytes32(v[:64])
+        enc.bytes32(v[64:128])
+        enc.bytes32(v[128:192])
         data = add_0x(enc.get())
         tx = self.template(sender_address, contract_address)
         tx = self.set_code(tx, data)
@@ -559,7 +576,16 @@ class DemurrageToken(ERC20):
     
     @classmethod
     def parse_redistributions(self, v):
-        return abi_decode_single(ABIContractType.BYTES32, v)
+        d = ABIContractDecoder()
+        v = strip_0x(v)
+        d.typ(ABIContractType.BYTES32)
+        d.typ(ABIContractType.BYTES32)
+        d.typ(ABIContractType.BYTES32)
+        d.val(v[:64])
+        d.val(v[64:128])
+        d.val(v[128:192])
+        r = d.decode()
+        return ''.join(r)
 
 
     @classmethod

python/erc20_demurrage_token/unittest/base.py

@@ -20,7 +20,7 @@ from erc20_demurrage_token import (
         DemurrageToken,
         )
 
-logg = logging.getLogger(__name__)
+logg = logging.getLogger()
 
 #BLOCKTIME = 5 # seconds
 TAX_LEVEL = int(10000 * 2) # 2%
@@ -95,6 +95,13 @@ class TestDemurrage(EthTesterCase):
 
     def setUp(self):
         super(TestDemurrage, self).setUp()
+#        token_deploy = TestTokenDeploy()
+#        self.settings = token_deploy.settings
+#        self.sink_address = token_deploy.sink_address
+#        self.start_block = token_deploy.start_block
+#        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')
@@ -126,13 +133,6 @@ class TestDemurrage(EthTesterCase):
         logg.debug('asserted within lower {} <= {} <= {}'.format(lower_target, v, target))
 
 
-    def assert_within_greater(self, v, target, tolerance_ppm):
-        higher_target = target + (target * (tolerance_ppm / 1000000))
-        self.assertLessEqual(v, higher_target)
-        self.assertGreaterEqual(v, target)
-        logg.debug('asserted within lower {} <= {} <= {}'.format(target, v, higher_target))
-
-
     def tearDown(self):
         pass
 

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

@@ -13,7 +13,6 @@ for m in ${modes[@]}; do
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_growth.py
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_amounts.py
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_single.py
-	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_burn.py
 done
 
 #modes=(SingleCap) # other contracts need to be updted

python/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = erc20-demurrage-token
-version = 0.2.0
+version = 0.1.1
 description = ERC20 token with redistributed continual demurrage
 author = Louis Holbrook
 author_email = dev@holbrook.no

python/tests/test_burn.py

@@ -1,320 +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 TestDemurrage
-
-logging.basicConfig(level=logging.INFO)
-logg = logging.getLogger()
-
-testdir = os.path.dirname(__file__)
-
-TAX_LEVEL = 2
-
-class TestBurn(TestDemurrage):
-
-    def setUp(self):
-        super(TestBurn, self).setUp()
-
-
-    def deploy(self, tax_level=None):
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        self.mode = os.environ.get('ERC20_DEMURRAGE_TOKEN_TEST_MODE')
-        if self.mode == None:
-            self.mode = 'MultiNocap'
-        logg.debug('executing test setup default mode {}'.format(self.mode))
-
-        if tax_level != None:
-            self.deployer.settings.demurrage_level = tax_level * (10 ** 32)
-        self.deployer.settings.sink_address = self.accounts[9]
-        self.deployer.sink_address = self.accounts[9]
-        super(TestBurn, self).deploy(c, self.mode)
-
-        logg.info('deployed with mode {}'.format(self.mode))
-
-
-    # Burn tokens and immediately check balances and supply
-    def test_burn_basic(self):
-        self.deploy()
-        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)
-
-
-    # burn tokens and check sink balance and supply after first redistribution period
-    def test_burned_redistribution(self):
-        self.deploy()
-        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)
-
-
-    # burn tokens and check sink and taxed balance and supply after first redistribution period
-    def test_burned_other_redistribution(self):
-        self.deploy()
-        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?
-
-
-    # verify expected results of balance and supply after multiple redistribution periods
-    def test_burn_accumulate(self):
-        self.deploy(tax_level=2/1000)
-        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.sink_address)
-        self.rpc.do(o)
-        o = receipt(tx_hash)
-        r = self.rpc.do(o)
-        self.assertEqual(r['status'], 1)
-
-        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.sink_address, self.default_supply)
-        r = self.rpc.do(o)
-
-        balance_share = int(self.default_supply / 2)
-        nonce_oracle = RPCNonceOracle(self.sink_address, self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-        (tx_hash, o) = c.transfer(self.address, self.sink_address, self.accounts[1], balance_share)
-        r = self.rpc.do(o)
-
-        new_supply = None
-        burn_rate = 1000
-        sink_bal = None
-        bob_bal = None
-        bob_refund = None
-
-        o = c.balance(self.address, self.accounts[1], sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        bob_bal = c.parse_balance(r)
-        prev_bob_bal = bob_bal
-
-        iterations = 100
-
-        for i in range(1, iterations + 1):
-            nonce_oracle = RPCNonceOracle(self.sink_address, self.rpc)
-            c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-            if bob_refund != None:
-                (tx_hash, o) = c.transfer(self.address, self.sink_address, self.accounts[1], bob_refund)
-                r = self.rpc.do(o)
-                o = receipt(tx_hash)
-                r = self.rpc.do(o)
-                self.assertEqual(r['status'], 1)
-
-            (tx_hash, o) = c.burn(self.address, self.sink_address, burn_rate)
-            r = self.rpc.do(o)
-            o = receipt(tx_hash)
-            r = self.rpc.do(o)
-            self.assertEqual(r['status'], 1)
-
-            nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-            c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-            o = c.total_supply(self.address, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            new_supply = c.parse_total_supply(r)
-
-            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 = c.balance(self.address, self.accounts[1], sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            bob_bal = c.parse_balance(r)
-            bob_refund = prev_bob_bal - bob_bal
-
-            o = c.balance(self.address, self.sink_address, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            burner_bal = c.parse_balance(r)
-
-            sum_supply = bob_bal + burner_bal
-          
-            o = c.total_burned(self.address, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            total_burned = c.parse_balance(r)
-
-            o = c.to_base_amount(self.address, total_burned, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            total_burned_base = c.parse_balance(r)
-
-            expected_supply = self.default_supply - (burn_rate * i)
-            logg.info('checking burn round {} balance burner {} bob {} supply {} expected {} summed {} burned {} base {}'.format(i, burner_bal, bob_bal, new_supply, expected_supply, sum_supply, total_burned, total_burned_base))
-            self.assertEqual(new_supply, expected_supply)
-
-        sum_supply = burner_bal + bob_bal
-        logg.debug('balances sink {} bob {} total {} supply real {} original {}'.format(sink_bal, bob_bal, sum_supply, new_supply, self.default_supply))
-
-        self.assert_within_lower(sum_supply, new_supply, 0.00001)
-        self.assert_within_greater(burner_bal, balance_share - total_burned, 0.1)
-
-        bob_delta = self.default_supply * ((2 / 1000000) / 1000)
-        self.assert_within_lower(bob_bal, balance_share - bob_delta, 0.1)
-        
-        self.assertEqual(total_burned, iterations * burn_rate)
-
-
-if __name__ == '__main__':
-    unittest.main()

python/tests/test_demurrage.py

@@ -1,133 +0,0 @@
-# standard imports
-import datetime
-import unittest
-import logging
-import os
-
-# external imports
-from chainlib.eth.nonce import RPCNonceOracle
-from chainlib.eth.tx import receipt
-
-# local imports
-from erc20_demurrage_token import DemurrageToken
-from erc20_demurrage_token.demurrage import DemurrageCalculator
-
-# test imports
-from erc20_demurrage_token.unittest.base import TestDemurrage
-
-logging.basicConfig(level=logging.INFO)
-logg = logging.getLogger()
-
-
-class TestDemurragePeriods(TestDemurrage):
-
-    def setUp(self):
-        super(TestDemurragePeriods, self).setUp()
-   
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        self.mode = os.environ.get('ERC20_DEMURRAGE_TOKEN_TEST_MODE')
-        if self.mode == None:
-            self.mode = 'MultiNocap'
-        logg.debug('executing test setup default mode {}'.format(self.mode))
-
-        self.deployer.settings.demurrage_level = (2 / 1000) * (10 ** 32)
-        self.deployer.settings.sink_address = self.accounts[9]
-        self.deployer.sink_address = self.accounts[9]
-        self.deploy(c, self.mode)
-
-        logg.info('deployed with mode {}'.format(self.mode))
-
-
-    # verify that tax level calculation is in ppm as expected
-    def test_ppm(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], self.default_supply)
-        r = self.rpc.do(o)
-
-        self.backend.time_travel(self.start_time + 60)
-
-        (tx_hash, o) = c.apply_demurrage(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.balance(self.address, self.accounts[1], sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        bob_bal = c.parse_balance(r)
-
-        o = c.balance(self.address, self.sink_address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        sink_bal = c.parse_balance(r)
-
-        o = c.total_supply(self.address, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        new_supply = c.parse_total_supply(r)
-
-        balance_delta = self.default_supply * ((2 / 1000000) / 1000) 
-        self.assertEqual(bob_bal, self.default_supply - balance_delta)
-
-
-
-    # verify balances and supply after multiple demurrage periods
-    def test_over_time(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], self.default_supply)
-        r = self.rpc.do(o)
-
-        o = c.balance(self.address, self.accounts[1], sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        bob_bal = c.parse_balance(r)
-        prev_bob_bal = bob_bal
-
-        nonce_oracle = RPCNonceOracle(self.sink_address, self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        iterations = 100
-
-        for i in range(1, iterations + 1):
-            self.backend.time_travel(self.start_time + (self.period_seconds * i))
-
-            (tx_hash, o) = c.transfer(self.address, self.sink_address, self.accounts[1], prev_bob_bal - bob_bal)
-            r = self.rpc.do(o)
-            o = receipt(tx_hash)
-            r = self.rpc.do(o)
-            self.assertEqual(r['status'], 1)
-
-            (tx_hash, o) = c.apply_demurrage(self.address, self.sink_address)
-            self.rpc.do(o)
-            o = receipt(tx_hash)
-            r = self.rpc.do(o)
-            self.assertEqual(r['status'], 1)
-
-            o = c.balance(self.address, self.accounts[1], sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            bob_bal = c.parse_balance(r)
-
-            o = c.balance(self.address, self.sink_address, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            sink_bal = c.parse_balance(r)
-
-            o = c.total_supply(self.address, sender_address=self.accounts[0])
-            r = self.rpc.do(o)
-            new_supply = c.parse_total_supply(r)
-
-            logg.info('round {} supply {} balance sink {} bob {}'.format(i, new_supply, sink_bal, bob_bal))
-
-        sum_supply = sink_bal + bob_bal
-
-        bob_delta = self.default_supply * ((2 / 1000000) / 100)
-
-        self.assert_within_lower(sum_supply, new_supply, 0.00001)
-        self.assert_within_greater(bob_bal, self.default_supply - bob_delta, 0.001)
-        self.assert_within_lower(sink_bal, bob_delta, 1000)
-        
-
-if __name__ == '__main__':
-    unittest.main()

python/tests/test_redistribution_unit.py

@@ -177,6 +177,7 @@ class TestRedistribution(TestDemurrageUnit):
 
         o = c.redistributions(self.address, 0, sender_address=self.accounts[0])
         redistribution = self.rpc.do(o)
+        logg.debug('redistribution {}'.format(redistribution))
         o = c.to_redistribution_supply(self.address, redistribution, sender_address=self.accounts[0])
         r = self.rpc.do(o)
         supply = c.parse_to_redistribution_item(r)

solidity/DemurrageTokenSingleNocap.sol

@@ -1,17 +1,15 @@
 pragma solidity >= 0.8.0;
 
+
 // SPDX-License-Identifier: GPL-3.0-or-later
 contract DemurrageTokenSingleCap {
 
-	// Redistribution bit field, with associated shifts and masks
-	// (Uses sub-byte boundaries)
-	bytes32[] public redistributions; // uint51(unused) | uint64(demurrageModifier) | uint36(participants) | uint72(value) | uint32(period)
-	uint8 constant shiftRedistributionPeriod 	= 0;
-	uint256 constant maskRedistributionPeriod 	= 0x00000000000000000000000000000000000000000000000000000000ffffffff; // (1 << 32) - 1
-	uint8 constant shiftRedistributionValue 	= 32;
-	uint256 constant maskRedistributionValue	= 0x00000000000000000000000000000000000000ffffffffffffffffff00000000; // ((1 << 72) - 1) << 32
-	uint8 constant shiftRedistributionDemurrage	= 104;
-	uint256 constant maskRedistributionDemurrage	= 0x0000000000ffffffffffffffffffffffffffff00000000000000000000000000; // ((1 << 36) - 1) << 140
+	struct redistributionItem {
+		uint32 period;
+		uint72 value;
+		uint104 demurrage;
+	}
+	redistributionItem[] public redistributions; // uint51(unused) | uint64(demurrageModifier) | uint36(participants) | uint72(value) | uint32(period)
 
 	// Account balances
 	mapping (address => uint256) account;
@@ -105,6 +103,8 @@ contract DemurrageTokenSingleCap {
 	event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); // EIP173
 
 	constructor(string memory _name, string memory _symbol, uint8 _decimals, uint128 _taxLevelMinute, uint256 _periodMinutes, address _defaultSinkAddress) public {
+		redistributionItem memory initialRedistribution;
+
 		// ACL setup
 		owner = msg.sender;
 		minter[owner] = true;
@@ -120,7 +120,7 @@ contract DemurrageTokenSingleCap {
 		periodDuration = _periodMinutes * 60;
 		demurrageAmount = uint128(nanoDivider) * 100;
 		taxLevel = _taxLevelMinute; // Represents 38 decimal places
-		bytes32 initialRedistribution = toRedistribution(0, demurrageAmount, 0, 1);
+		initialRedistribution = toRedistribution(0, demurrageAmount, 0, 1);
 		redistributions.push(initialRedistribution);
 
 		// Misc settings
@@ -220,31 +220,32 @@ contract DemurrageTokenSingleCap {
 	}
 
 	// Deserializes the redistribution word
-	// uint95(unused) | uint20(demurrageModifier) | uint36(participants) | uint72(value) | uint32(period)
-	function toRedistribution(uint256 _participants, uint256 _demurrageModifierPpm, uint256 _value, uint256 _period) public pure returns(bytes32) {
-		bytes32 redistribution;
+	function toRedistribution(uint256 _participants, uint256 _demurrageModifierPpm, uint256 _value, uint256 _period) public pure returns(redistributionItem memory) {
+		redistributionItem memory redistribution;
 
-		redistribution |= bytes32((_demurrageModifierPpm << shiftRedistributionDemurrage) & maskRedistributionDemurrage);
-		redistribution |= bytes32((_value << shiftRedistributionValue) & maskRedistributionValue); 
-		redistribution |= bytes32(_period & maskRedistributionPeriod);
+		redistribution.period = uint32(_period);
+		redistribution.value = uint72(_value);
+		redistribution.demurrage = uint104(_demurrageModifierPpm);
 		return redistribution;
+
 	}
 
 	// Serializes the demurrage period part of the redistribution word
-	function toRedistributionPeriod(bytes32 redistribution) public pure returns (uint256) {
-		return uint256(redistribution) & maskRedistributionPeriod;
+	function toRedistributionPeriod(redistributionItem memory _redistribution) public pure returns (uint256) {
+		return uint256(_redistribution.period);
 	}
 
 	// Serializes the supply part of the redistribution word
-	function toRedistributionSupply(bytes32 redistribution) public pure returns (uint256) {
-		return (uint256(redistribution) & maskRedistributionValue) >> shiftRedistributionValue;
+	function toRedistributionSupply(redistributionItem memory _redistribution) public pure returns (uint256) {
+		return uint256(_redistribution.value);
 	}
 
 	// Serializes the number of participants part of the redistribution word
-	function toRedistributionDemurrageModifier(bytes32 redistribution) public pure returns (uint256) {
-		return (uint256(redistribution) & maskRedistributionDemurrage) >> shiftRedistributionDemurrage;
+	function toRedistributionDemurrageModifier(redistributionItem memory _redistribution) public pure returns (uint256) {
+		return uint256(_redistribution.demurrage);
 	}
 
+
 	// Client accessor to the redistributions array length
 	function redistributionCount() public view returns (uint256) {
 		return redistributions.length;
@@ -252,15 +253,14 @@ contract DemurrageTokenSingleCap {
 
 	// Save the current total supply amount to the current redistribution period
 	function saveRedistributionSupply() private returns (bool) {
-		uint256 currentRedistribution;
+		redistributionItem memory currentRedistribution;
 		uint256 grownSupply;
 
 		grownSupply = totalSupply();
-		currentRedistribution = uint256(redistributions[redistributions.length-1]);
-		currentRedistribution &= (~maskRedistributionValue);
-		currentRedistribution |= (grownSupply << shiftRedistributionValue);
+		currentRedistribution = redistributions[redistributions.length-1];
+		currentRedistribution.value = uint72(grownSupply);
 
-		redistributions[redistributions.length-1] = bytes32(currentRedistribution);
+		redistributions[redistributions.length-1] = currentRedistribution;
 		return true;
 	}
 
@@ -270,14 +270,15 @@ contract DemurrageTokenSingleCap {
 	}
 
 	// Retrieve next redistribution if the period threshold has been crossed
-	function checkPeriod() private view returns (bytes32) {
-		bytes32 lastRedistribution;
+	function checkPeriod() private view returns (redistributionItem memory) {
+		redistributionItem memory lastRedistribution;
+		redistributionItem memory emptyRedistribution;
 		uint256 currentPeriod;
 
 		lastRedistribution =  redistributions[lastPeriod];
 		currentPeriod = this.actualPeriod();
 		if (currentPeriod <= toRedistributionPeriod(lastRedistribution)) {
-			return bytes32(0x00);
+			return emptyRedistribution;
 		}
 		return lastRedistribution;
 	}
@@ -289,7 +290,7 @@ contract DemurrageTokenSingleCap {
 		return difference / resolutionFactor;
 	}
 
-	function getDistributionFromRedistribution(bytes32 _redistribution) public returns (uint256) {
+	function getDistributionFromRedistribution(redistributionItem memory _redistribution) public returns (uint256) {
 		uint256 redistributionSupply;
 		uint256 redistributionDemurrage;
 
@@ -299,7 +300,7 @@ contract DemurrageTokenSingleCap {
 	}
 
 	// Returns the amount sent to the sink address
-	function applyDefaultRedistribution(bytes32 _redistribution) private returns (uint256) {
+	function applyDefaultRedistribution(redistributionItem memory _redistribution) private returns (uint256) {
 		uint256 unit;
 		uint256 baseUnit;
 	
@@ -354,21 +355,34 @@ contract DemurrageTokenSingleCap {
 		return (block.timestamp - _target) / 60;
 	}
 
+	function isEmptyRedistribution(redistributionItem memory _redistribution) public pure returns(bool) {
+		if (_redistribution.period > 0) {
+			return false;
+		}
+		if (_redistribution.value > 0) {
+			return false;
+		}
+		if (_redistribution.demurrage > 0) {
+			return false;
+		}
+		return true;
+	}
+
 	// Recalculate the demurrage modifier for the new period
 	// Note that the supply for the consecutive period will be taken at the time of code execution, and thus not necessarily at the time when the redistribution period threshold was crossed.
 	function changePeriod() public returns (bool) {
-		bytes32 currentRedistribution;
-		bytes32 nextRedistribution;
+		redistributionItem memory currentRedistribution;
+		redistributionItem memory nextRedistribution;
+		redistributionItem memory lastRedistribution;
 		uint256 currentPeriod;
 		uint256 lastDemurrageAmount;
-		bytes32 lastRedistribution;
 		uint256 nextRedistributionDemurrage;
 		uint256 demurrageCounts;
 		uint256 nextPeriod;
 
 		applyDemurrage();
 		currentRedistribution = checkPeriod();
-		if (currentRedistribution == bytes32(0x00)) {
+		if (isEmptyRedistribution(currentRedistribution)) {
 			return false;
 		}
 
@@ -389,18 +403,18 @@ contract DemurrageTokenSingleCap {
 	}
 
 	// Reverse a value reduced by demurrage by the given period to its original value
-	function growBy(uint256 _value, uint256 _period) public view returns (uint256) {
-		uint256 valueFactor;
-		uint256 truncatedTaxLevel;
-	      
-		valueFactor = growthResolutionFactor;
-		truncatedTaxLevel = taxLevel / nanoDivider;
-
-		for (uint256 i = 0; i < _period; i++) {
-			valueFactor = valueFactor + ((valueFactor * truncatedTaxLevel) / growthResolutionFactor);
-		}
-		return (valueFactor * _value) / growthResolutionFactor;
-	}
+//	function growBy(uint256 _value, uint256 _period) public view returns (uint256) {
+//		uint256 valueFactor;
+//		uint256 truncatedTaxLevel;
+//	      
+//		valueFactor = growthResolutionFactor;
+//		truncatedTaxLevel = taxLevel / nanoDivider;
+//
+//		for (uint256 i = 0; i < _period; i++) {
+//			valueFactor = valueFactor + ((valueFactor * truncatedTaxLevel) / growthResolutionFactor);
+//		}
+//		return (valueFactor * _value) / growthResolutionFactor;
+//	}
 
 	// Calculate a value reduced by demurrage by the given period
 	function decayBy(uint256 _value, uint256 _period) public view returns (uint256) {

solidity/Makefile

@@ -1,6 +1,6 @@
 SOLC = /usr/bin/solc
 
-all: multi single
+all: single_nocap
 
 multi_nocap:
 	$(SOLC) DemurrageTokenMultiNocap.sol --abi --evm-version byzantium | awk 'NR>3' > DemurrageTokenMultiNocap.json
@@ -32,15 +32,8 @@ test: all
 	python ../python/tests/test_redistribution.py
 	python ../python/tests/test_pure.py
 
-#install: all
-install: single_nocap
-	#cp -v DemurrageToken*.{json,bin} ../python/erc20_demurrage_token/data/
-	cp -v DemurrageTokenSingleNocap.json ../python/erc20_demurrage_token/data/
-	cp -v DemurrageTokenSingleNocap.bin ../python/erc20_demurrage_token/data/
-
-install-broken: all
-	cp -v DemurrageToken*.{json,bin} ../python/erc20_demurrage_token/data/
-
-
+install: all
+	cp -v DemurrageToken*.json ../python/erc20_demurrage_token/data/
+	cp -v DemurrageToken*.bin ../python/erc20_demurrage_token/data/
 	
 .PHONY: test install