Remove commented contract code, makefile single nocap only

Add apply demurrage cli tool

See merge request cicnet/erc20-demurrage-token!9

.gitignore

@@ -6,3 +6,5 @@ __pycache__
 gmon.out
 solidity/*.json
 solidity/*.bin
+.venv
+venv

.gitlab-ci.yml

@@ -0,0 +1,36 @@
+# To contribute improvements to CI/CD templates, please follow the Development guide at:
+# https://docs.gitlab.com/ee/development/cicd/templates.html
+# This specific template is located at:
+# https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Python.gitlab-ci.yml
+
+# Official language image. Look for the different tagged releases at:
+# https://hub.docker.com/r/library/python/tags/
+image: python:3.8
+
+# Change pip's cache directory to be inside the project directory since we can
+# only cache local items.
+variables:
+  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
+
+# Pip's cache doesn't store the python packages
+# https://pip.pypa.io/en/stable/reference/pip_install/#caching
+#
+# If you want to also cache the installed packages, you have to install
+# them in a virtualenv and cache it as well.
+cache:
+  paths:
+    - .cache/pip
+    - venv/
+
+before_script:
+  - cd ./python
+  - python --version  # For debugging
+  - pip install virtualenv
+  - virtualenv venv
+  - source venv/bin/activate
+
+test:
+  script:
+    - pip install -r requirements.txt -r test_requirements.txt --extra-index-url https://pip.grassrootseconomics.net
+    - bash run_tests.sh 
+

python/CHANGELOG

@@ -1,4 +1,14 @@
-- 0.0.2-pending
+- 0.1.1
+	* Settable demurrage steps for apply demurrage cli tool
+- 0.1.0
+	* Dependency upgrades
+- 0.0.11
+	* Apply demurrage cli tool
+- 0.0.10
+	* Settable sink address
+- 0.0.9
+	* Correct redistribution amount for SingleNocap contract
+- 0.0.2
 	* Move to chainlib-eth
-- 0.0.1-unreleased
+- 0.0.1
 	* Interface for redistributed and non-redistributed, with or without cap

python/erc20_demurrage_token/demurrage.py

@@ -9,8 +9,7 @@ from chainlib.eth.constant import ZERO_ADDRESS
 # local imports
 from .token import DemurrageToken
 
-logging.basicConfig(level=logging.DEBUG)
-logg = logging.getLogger()
+logg = logging.getLogger(__name__)
 
 
 class DemurrageCalculator:

python/erc20_demurrage_token/runnable/apply.py

@@ -0,0 +1,144 @@
+"""Deploy sarafu token
+
+.. moduleauthor:: Louis Holbrook <dev@holbrook.no>
+.. pgp:: 0826EDA1702D1E87C6E2875121D2E7BB88C2A746 
+
+"""
+
+# standard imports
+import sys
+import os
+import json
+import argparse
+import logging
+import datetime
+import math
+
+# 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.block import (
+        block_latest,
+        block_by_number,
+        Block,
+        )
+from chainlib.eth.connection import EthHTTPConnection
+from chainlib.eth.tx import receipt
+from chainlib.eth.constant import ZERO_ADDRESS
+import chainlib.eth.cli
+from hexathon import to_int as hex_to_int
+
+# local imports
+import erc20_demurrage_token
+from erc20_demurrage_token import (
+        DemurrageToken,
+        DemurrageTokenSettings,
+        )
+
+logging.basicConfig(level=logging.WARNING)
+logg = logging.getLogger()
+
+script_dir = os.path.dirname(__file__)
+data_dir = os.path.join(script_dir, '..', 'data')
+
+config_dir = os.path.join(data_dir, 'config')
+
+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()
+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))
+
+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():
+    o = block_latest()
+    r = conn.do(o)
+ 
+    block_start_number = None
+    try:
+        block_start_number = hex_to_int(r)
+    except TypeError:
+        block_start_number = int(r)
+
+    o = block_by_number(block_start_number)
+    r = conn.do(o)
+
+    block_start = Block(r)
+    block_start_timestamp = block_start.timestamp
+    block_start_datetime = datetime.datetime.fromtimestamp(block_start_timestamp)
+
+    gas_oracle = rpc.get_gas_oracle()
+    c = DemurrageToken(chain_spec, gas_oracle=gas_oracle)
+    o = c.demurrage_timestamp(config.get('_EXEC_ADDRESS'))
+    r = conn.do(o)
+
+    demurrage_timestamp = None
+    try:
+        demurrage_timestamp = hex_to_int(r)
+    except TypeError:
+        demurrage_timestamp = int(r)
+    demurrage_datetime = datetime.datetime.fromtimestamp(demurrage_timestamp)
+
+    total_seconds = block_start_timestamp - demurrage_timestamp
+    total_steps = total_seconds / 60
+
+    if total_steps < 1.0:
+        logg.error('only {} seconds since last demurrage application, skipping'.format(total_seconds))
+        return
+
+    logg.debug('block start is at {} demurrage is at {} -> {} minutes'.format(
+        block_start_datetime,
+        demurrage_datetime,
+        total_steps,
+        ))
+
+    rounds = 1
+    if config.get('_STEPS') > 0:
+        rounds = math.ceil(total_steps / config.get('_STEPS'))
+
+    logg.info('will perform {} rounds of {} steps'.format(rounds, config.get('_STEPS')))
+
+    last_tx_hash = None
+    for i in range(rounds):
+        signer = rpc.get_signer()
+        signer_address = rpc.get_sender_address()
+
+        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 config.get('_RPC_SEND'):
+            print(tx_hash_hex)
+            conn.do(o)
+            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')
+                    sys.exit(1)
+        else:
+            print(o)
+
+
+
+if __name__ == '__main__':
+    main()

python/erc20_demurrage_token/runnable/deploy.py

@@ -14,8 +14,8 @@ import logging
 
 # external imports
 import confini
-from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer
-from crypto_dev_signer.keystore.dict import DictKeystore
+from funga.eth.signer import EIP155Signer
+from funga.eth.keystore.dict import DictKeystore
 from chainlib.chain import ChainSpec
 from chainlib.eth.nonce import (
         RPCNonceOracle,
@@ -49,8 +49,8 @@ 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', default=18, type=int, help='Token decimals')
-argparser.add_argument('--sink-address', dest='sink_address', default=ZERO_ADDRESS, type=str, help='demurrage level,ppm per minute') 
+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', type=int, help='redistribution period, minutes (0 = deactivate)') # default 10080 = week
 argparser.add_argument('--multi', action='store_true', help='automatic redistribution')
@@ -90,7 +90,6 @@ conn = rpc.connect_by_config(config)
 
 chain_spec = ChainSpec.from_chain_str(config.get('CHAIN_SPEC'))
 
-
 def main():
     signer = rpc.get_signer()
     signer_address = rpc.get_sender_address()

python/erc20_demurrage_token/sim/sim.py

@@ -20,8 +20,8 @@ from chainlib.eth.block import (
         block_by_number,
         block_by_hash,
         )
-from crypto_dev_signer.keystore.dict import DictKeystore
-from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer
+from funga.eth.keystore.dict import DictKeystore
+from funga.eth.signer import EIP155Signer
 from hexathon import (
         strip_0x,
         add_0x,

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,
         )
@@ -38,6 +39,15 @@ 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 = {}
@@ -108,6 +118,34 @@ class DemurrageToken(ERC20):
         return DemurrageToken.__bytecode[name]
 
 
+    def increase_allowance(self, contract_address, sender_address, address, value, tx_format=TxFormat.JSONRPC):
+        enc = ABIContractEncoder()
+        enc.method('increaseAllowance')
+        enc.typ(ABIContractType.ADDRESS)
+        enc.typ(ABIContractType.UINT256)
+        enc.address(address)
+        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 decrease_allowance(self, contract_address, sender_address, address, value, tx_format=TxFormat.JSONRPC):
+        enc = ABIContractEncoder()
+        enc.method('decreaseAllowance')
+        enc.typ(ABIContractType.ADDRESS)
+        enc.typ(ABIContractType.UINT256)
+        enc.address(address)
+        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 add_minter(self, contract_address, sender_address, address, tx_format=TxFormat.JSONRPC):
         enc = ABIContractEncoder()
         enc.method('addMinter')
@@ -146,6 +184,33 @@ 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()
@@ -246,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)
@@ -257,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)
@@ -280,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)
@@ -297,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)
@@ -325,8 +403,19 @@ class DemurrageToken(ERC20):
         return o
 
 
-    def apply_demurrage(self, contract_address, sender_address):
-        return self.transact_noarg('applyDemurrage', contract_address, sender_address)
+    def apply_demurrage(self, contract_address, sender_address, limit=0, tx_format=TxFormat.JSONRPC):
+        if limit == 0:
+            return self.transact_noarg('applyDemurrage', contract_address, sender_address)
+
+        enc = ABIContractEncoder()
+        enc.method('applyDemurrageLimited')
+        enc.typ(ABIContractType.UINT256)
+        enc.uint256(limit)
+        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 change_period(self, contract_address, sender_address):
@@ -369,28 +458,32 @@ class DemurrageToken(ERC20):
         return self.call_noarg('demurrageAmount', contract_address, sender_address=sender_address)
 
 
+    def demurrage_timestamp(self, contract_address, sender_address=ZERO_ADDRESS):
+        return self.call_noarg('demurrageTimestamp', contract_address, sender_address=sender_address)
+
+
     def supply_cap(self, contract_address, sender_address=ZERO_ADDRESS):
         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)
@@ -436,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)
@@ -480,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
@@ -502,6 +607,7 @@ 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)
@@ -525,3 +631,8 @@ 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,18 +32,19 @@ PERIOD = 10
 
 class TestTokenDeploy:
 
-    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
+    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
 
         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)
@@ -101,7 +102,12 @@ class TestDemurrage(EthTesterCase):
 #        self.start_time = token_deploy.start_time
 #        self.default_supply = self.default_supply
 #        self.default_supply_cap = self.default_supply_cap
-        self.deployer = TestTokenDeploy(self.rpc)
+        period = PERIOD
+        try:
+            period = getattr(self, 'period')
+        except AttributeError as e:
+            pass
+        self.deployer = TestTokenDeploy(self.rpc, period=period)
         self.default_supply = self.deployer.default_supply
         self.default_supply_cap = self.deployer.default_supply_cap
         self.start_block = None
@@ -203,10 +209,11 @@ class TestDemurrageCap(TestDemurrage):
 class TestDemurrageUnit(TestDemurrage):
 
     def setUp(self):
-        super(TestDemurrage, self).setUp()
+        self.period = 1
+        self.period_seconds = self.period * 60
+        self.tax_level = TAX_LEVEL
 
-        self.tax_level = 50
-        self.period_seconds = 60
+        super(TestDemurrageUnit, self).setUp()
 
         nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
         self.settings = DemurrageTokenSettings()

python/requirements.txt

@@ -1,3 +1,3 @@
-chainlib>=0.0.9a3,<=0.1.0
-eth-erc20>=0.1.2a1,<0.2.0
-crypto-dev-signer>=0.4.15a1,<=0.4.15
+chainlib-eth>=0.1.0,<0.2.0
+eth-erc20~=0.3.0
+funga-eth~=0.6.0

python/run_tests.sh

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

python/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = erc20-demurrage-token
-version = 0.0.5a2
+version = 0.1.1
 description = ERC20 token with redistributed continual demurrage
 author = Louis Holbrook
 author_email = dev@holbrook.no
@@ -25,12 +25,13 @@ licence_files =
 
 [options]
 include_package_data = True
-python_requires = >= 3.6
+python_requires = >= 3.7
 packages =
 	erc20_demurrage_token
 	erc20_demurrage_token.runnable
 	erc20_demurrage_token.data
 	erc20_demurrage_token.sim
+	erc20_demurrage_token.unittest
 
 [options.package_data]
 * =
@@ -40,3 +41,4 @@ packages =
 [options.entry_points]
 console_scripts =
 	erc20-demurrage-token-deploy = erc20_demurrage_token.runnable.deploy:main
+	erc20-demurrage-token-apply = erc20_demurrage_token.runnable.apply:main

python/tests/test_basic.py

@@ -28,179 +28,205 @@ testdir = os.path.dirname(__file__)
 
 class TestBasic(TestDemurrageDefault):
 
-#    def test_hello(self):
-#        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-#        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-#        o = c.actual_period(self.address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        
-#        self.backend.time_travel(self.start_time + self.period_seconds + 1)
-#        o = c.actual_period(self.address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#
-#
-#    def test_balance(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], 1024)
-#        r = self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, 1024)
-#
-#
-#    def test_apply_demurrage(self):
-#        modifier = (10 ** 38)
-#
-#        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-#        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-#
-#        o = c.demurrage_amount(self.address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        demurrage_amount = c.parse_demurrage_amount(r)
-#        self.assertEqual(modifier, demurrage_amount)
-#
-#        o = block_latest()
-#        r = self.rpc.do(o)
-#        o = block_by_number(r)
-#        b = self.rpc.do(o)
-#        logg.debug('block {} start {}'.format(b['timestamp'], self.start_time))
-#
-#        self.backend.time_travel(self.start_time + 2)
-#        (tx_hash, o) = c.apply_demurrage(self.address, sender_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.demurrage_amount(self.address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        demurrage_amount = c.parse_demurrage_amount(r)
-#        self.assertEqual(modifier, demurrage_amount)
-#
-#        self.backend.time_travel(self.start_time + 61)
-#        (tx_hash, o) = c.apply_demurrage(self.address, sender_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.demurrage_amount(self.address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        demurrage_amount = c.parse_demurrage_amount(r)
-#        modifier_base = 1000000 - self.tax_level
-#        logg.debug('modifier base {}'.format(modifier_base))
-#        modifier = int(modifier_base * (10 ** 32)) # 38 decimal places minus 6 (1000000)
-#        self.assertEqual(modifier, demurrage_amount)
-#
-#        self.backend.time_travel(self.start_time + 601)
-#        (tx_hash, o) = c.apply_demurrage(self.address, sender_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.demurrage_amount(self.address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        demurrage_amount = c.parse_demurrage_amount(r)
-#        modifier_base = ((1000000 - self.tax_level) / 1000000) ** 10
-#        modifier = int(modifier_base * (10 ** 12))
-#
-#        rounding_tolerance_nano = 4000000 # 0.000004% precision
-#        demurrage_amount_truncate = int(demurrage_amount / (10 ** 26)) # equals 12 decimal places
-#        self.assertGreaterEqual(modifier, demurrage_amount_truncate - rounding_tolerance_nano)
-#        self.assertLessEqual(modifier, demurrage_amount_truncate)
-#
-#
-#    def test_mint(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], 1024)
-#        r = self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, 1024)
-#
-#        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[1], 976)
-#        r = self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, 2000)
-#
-#
-#        self.backend.time_travel(self.start_time + 61)
-#        (tx_hash, o) = c.apply_demurrage(self.address, sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, int(2000 * 0.98))
-#
-#
-#    def test_minter_control(self):
-#        nonce_oracle = RPCNonceOracle(self.accounts[1], self.rpc)
-#        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-#
-#        (tx_hash, o) = c.mint_to(self.address, self.accounts[1], self.accounts[2], 1024)
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 0)
-#            
-#        (tx_hash, o) = c.add_minter(self.address, self.accounts[1], self.accounts[1])
-#        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])
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#        nonce_oracle = RPCNonceOracle(self.accounts[1], self.rpc)
-#        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-#        (tx_hash, o) = c.mint_to(self.address, self.accounts[1], self.accounts[2], 1024)
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#        (tx_hash, o) = c.add_minter(self.address, self.accounts[1], self.accounts[2])
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 0)
-#
-#        (tx_hash, o) = c.remove_minter(self.address, self.accounts[1], self.accounts[1])
-#        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[1], self.accounts[2], 1024)
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 0)
-#            
-#
+    def test_hello(self):
+        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        o = c.actual_period(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        
+        self.backend.time_travel(self.start_time + self.period_seconds + 1)
+        o = c.actual_period(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+
+
+    def test_balance(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], 1024)
+        r = self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 1024)
+
+
+    def test_apply_demurrage_limited(self):
+        modifier = (10 ** 28)
+
+        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+
+        o = c.demurrage_amount(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        demurrage_amount = c.parse_demurrage_amount(r)
+        self.assertEqual(modifier, demurrage_amount)
+
+        self.backend.time_travel(self.start_time + 120)
+        (tx_hash, o) = c.apply_demurrage(self.address, sender_address=self.accounts[0], limit=1)
+        r = self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        o = c.demurrage_amount(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        demurrage_amount = c.parse_demurrage_amount(r)
+        modifier_base = 1000000 - self.tax_level
+        modifier = int(modifier_base * (10 ** 22)) # 38 decimal places minus 6 (1000000)
+        self.assertEqual(modifier, demurrage_amount)
+
+
+    def test_apply_demurrage(self):
+        modifier = (10 ** 28)
+
+        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+
+        o = c.demurrage_amount(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        demurrage_amount = c.parse_demurrage_amount(r)
+        self.assertEqual(modifier, demurrage_amount)
+
+        o = block_latest()
+        r = self.rpc.do(o)
+        o = block_by_number(r)
+        b = self.rpc.do(o)
+        logg.debug('block {} start {}'.format(b['timestamp'], self.start_time))
+
+        self.backend.time_travel(self.start_time + 2)
+        (tx_hash, o) = c.apply_demurrage(self.address, sender_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.demurrage_amount(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        demurrage_amount = c.parse_demurrage_amount(r)
+        self.assertEqual(modifier, demurrage_amount)
+
+        self.backend.time_travel(self.start_time + 61)
+        (tx_hash, o) = c.apply_demurrage(self.address, sender_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.demurrage_amount(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        demurrage_amount = c.parse_demurrage_amount(r)
+        modifier_base = 1000000 - self.tax_level
+        modifier = int(modifier_base * (10 ** 22)) # 38 decimal places minus 6 (1000000)
+        self.assertEqual(modifier, demurrage_amount)
+
+        self.backend.time_travel(self.start_time + 601)
+        (tx_hash, o) = c.apply_demurrage(self.address, sender_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.demurrage_amount(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        demurrage_amount = c.parse_demurrage_amount(r)
+        modifier_base = ((1000000 - self.tax_level) / 1000000) ** 10
+        logg.warning('mod base {}'.format(modifier_base))
+        modifier = int(modifier_base * (10 ** 12))
+
+        rounding_tolerance_nano = 4000000 # 0.000004% precision
+        demurrage_amount_truncate = int(demurrage_amount / (10 ** 16)) # equals 38 decimal places - 14 for the modifier magniture - 2 for percent int calc + 6 for token decimals <- TODO verify this calc
+        self.assertGreaterEqual(modifier, demurrage_amount_truncate - rounding_tolerance_nano)
+        self.assertLessEqual(modifier, demurrage_amount_truncate)
+
+
+    def test_mint(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], 1024)
+        r = self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 1024)
+
+        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[1], 976)
+        r = self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 2000)
+
+
+        self.backend.time_travel(self.start_time + 61)
+        (tx_hash, o) = c.apply_demurrage(self.address, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, int(2000 * 0.98))
+
+
+    def test_minter_control(self):
+        nonce_oracle = RPCNonceOracle(self.accounts[1], self.rpc)
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+
+        (tx_hash, o) = c.mint_to(self.address, self.accounts[1], self.accounts[2], 1024)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 0)
+            
+        (tx_hash, o) = c.add_minter(self.address, self.accounts[1], self.accounts[1])
+        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])
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        nonce_oracle = RPCNonceOracle(self.accounts[1], self.rpc)
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        (tx_hash, o) = c.mint_to(self.address, self.accounts[1], self.accounts[2], 1024)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        (tx_hash, o) = c.add_minter(self.address, self.accounts[1], self.accounts[2])
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 0)
+
+        (tx_hash, o) = c.remove_minter(self.address, self.accounts[1], self.accounts[1])
+        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[1], self.accounts[2], 1024)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 0)
+            
+
     def test_base_amount(self):
         nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
         c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
@@ -216,78 +242,129 @@ class TestBasic(TestDemurrageDefault):
         amount = c.parse_to_base_amount(r)
         self.assertEqual(amount, 1020)
 
-#
-#    def test_transfer(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], 1024)
-#        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.transfer(self.address, self.accounts[1], self.accounts[2], 500)
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, 524)
-#
-#        o = c.balance_of(self.address, self.accounts[2], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, 500)
-#
-#        nonce_oracle = RPCNonceOracle(self.accounts[2], self.rpc)
-#        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-#        (tx_hash, o) = c.transfer(self.address, self.accounts[2], self.accounts[1], 500)
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#
-#       
-#
-#    def test_transfer_from(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], 1024)
-#        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.approve(self.address, self.accounts[1], self.accounts[2], 500)
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-#        
-#        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, 1024)
-#
-#        nonce_oracle = RPCNonceOracle(self.accounts[2], self.rpc)
-#        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-#        (tx_hash, o) = c.transfer_from(self.address, self.accounts[2], self.accounts[1], self.accounts[3], 500)
-#        self.rpc.do(o)
-#        o = receipt(tx_hash)
-#        r = self.rpc.do(o)
-#        self.assertEqual(r['status'], 1)
-# 
-#        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, 524)
-#
-#        o = c.balance_of(self.address, self.accounts[3], sender_address=self.accounts[0])
-#        r = self.rpc.do(o)
-#        balance = c.parse_balance_of(r)
-#        self.assertEqual(balance, 500)
+
+    def test_transfer(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], 1024)
+        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.transfer(self.address, self.accounts[1], self.accounts[2], 500)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 524)
+
+        o = c.balance_of(self.address, self.accounts[2], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 500)
+
+        nonce_oracle = RPCNonceOracle(self.accounts[2], self.rpc)
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        (tx_hash, o) = c.transfer(self.address, self.accounts[2], self.accounts[1], 500)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+      
+    def test_approve(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.approve(self.address, self.accounts[0], self.accounts[1], 500)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+ 
+        (tx_hash, o) = c.approve(self.address, self.accounts[0], self.accounts[1], 600)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 0)
+
+        (tx_hash, o) = c.approve(self.address, self.accounts[0], self.accounts[1], 0)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        (tx_hash, o) = c.approve(self.address, self.accounts[0], self.accounts[1], 600)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        (tx_hash, o) = c.increase_allowance(self.address, self.accounts[0], self.accounts[1], 200)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        (tx_hash, o) = c.decrease_allowance(self.address, self.accounts[0], self.accounts[1], 800)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        (tx_hash, o) = c.approve(self.address, self.accounts[0], self.accounts[1], 42)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+
+    def test_transfer_from(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], 1024)
+        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.approve(self.address, self.accounts[1], self.accounts[2], 500)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+        
+        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 1024)
+
+        nonce_oracle = RPCNonceOracle(self.accounts[2], self.rpc)
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        (tx_hash, o) = c.transfer_from(self.address, self.accounts[2], self.accounts[1], self.accounts[3], 500)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+ 
+        o = c.balance_of(self.address, self.accounts[1], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 524)
+
+        o = c.balance_of(self.address, self.accounts[3], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 500)
+
+        (tx_hash, o) = c.transfer_from(self.address, self.accounts[2], self.accounts[1], self.accounts[3], 1)
+        self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 0)
 
 
 if __name__ == '__main__':

python/tests/test_growth.py

@@ -28,23 +28,23 @@ testdir = os.path.dirname(__file__)
 
 class TestGrowth(TestDemurrageDefault):
 
-    def test_grow_by(self):
-        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
-        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
-
-        growth_factor = (1000000 + self.tax_level) / 1000000
-        v = 1000000000
-        o = c.grow_by(self.address, v, 1, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        g = c.parse_grow_by(r)
-        self.assertEqual(int(v * growth_factor),  g)
-
-        period = 10
-        growth_factor = (1 + (self.tax_level) / 1000000) ** period
-        o = c.grow_by(self.address, v, period, sender_address=self.accounts[0])
-        r = self.rpc.do(o)
-        g = c.parse_grow_by(r)
-        self.assertEqual(int(v * growth_factor),  g)
+#    def test_grow_by(self):
+#        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
+#        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+#
+#        growth_factor = (1000000 + self.tax_level) / 1000000
+#        v = 1000000000
+#        o = c.grow_by(self.address, v, 1, sender_address=self.accounts[0])
+#        r = self.rpc.do(o)
+#        g = c.parse_grow_by(r)
+#        self.assertEqual(int(v * growth_factor),  g)
+#
+#        period = 10
+#        growth_factor = (1 + (self.tax_level) / 1000000) ** period
+#        o = c.grow_by(self.address, v, period, sender_address=self.accounts[0])
+#        r = self.rpc.do(o)
+#        g = c.parse_grow_by(r)
+#        self.assertEqual(int(v * growth_factor),  g)
 
 
     def test_decay_by(self):
@@ -63,7 +63,7 @@ class TestGrowth(TestDemurrageDefault):
         o = c.decay_by(self.address, v, period, sender_address=self.accounts[0])
         r = self.rpc.do(o)
         g = c.parse_decay_by(r)
-        self.assertEqual(int(v * growth_factor),  g)
+        self.assertEqual(int(v * growth_factor), g)
 
 
 if __name__ == '__main__':

python/tests/test_period.py

@@ -7,7 +7,15 @@ 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.tx import (
+        receipt,
+        TxFactory,
+        TxFormat,
+        )
+from chainlib.eth.contract import (
+        ABIContractEncoder,
+        ABIContractType,
+        )
 
 # local imports
 from erc20_demurrage_token import DemurrageToken
@@ -103,5 +111,90 @@ class TestPeriod(TestDemurrageDefault):
         self.assertEqual(modifier, period)
 
 
+    def test_change_sink(self):
+        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+
+        o = c.balance_of(self.address, ZERO_ADDRESS, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 0)
+
+        (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[1], 102400000000)
+        r = self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        self.backend.time_travel(self.start_time + self.period_seconds + 1)
+
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        (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.balance_of(self.address, ZERO_ADDRESS, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertGreater(balance, 0)
+        old_sink_balance = balance
+
+        o = c.balance_of(self.address, self.accounts[3], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertEqual(balance, 0)
+
+        nonce_oracle = RPCNonceOracle(self.accounts[5], self.rpc)
+        c = TxFactory(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        enc = ABIContractEncoder()
+        enc.method('setSinkAddress')
+        enc.typ(ABIContractType.ADDRESS)
+        enc.address(self.accounts[3])
+        data = enc.get()
+        o = c.template(self.accounts[5], self.address, use_nonce=True)
+        o = c.set_code(o, data)
+        (tx_hash, o) = c.finalize(o, TxFormat.JSONRPC)
+        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 = TxFactory(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        enc = ABIContractEncoder()
+        enc.method('setSinkAddress')
+        enc.typ(ABIContractType.ADDRESS)
+        enc.address(self.accounts[3])
+        data = enc.get()
+        o = c.template(self.accounts[0], self.address, use_nonce=True)
+        o = c.set_code(o, data)
+        (tx_hash, o) = c.finalize(o, TxFormat.JSONRPC)
+        r = self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        self.backend.time_travel(self.start_time + (self.period_seconds * 2) + 1)
+
+        c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        (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.balance_of(self.address, ZERO_ADDRESS, sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertLess(balance, old_sink_balance)
+
+        o = c.balance_of(self.address, self.accounts[3], sender_address=self.accounts[0])
+        r = self.rpc.do(o)
+        balance = c.parse_balance_of(r)
+        self.assertGreater(balance, 0)
+
+
 if __name__ == '__main__':
     unittest.main()

python/tests/test_redistribution.py

@@ -31,6 +31,8 @@ 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

@@ -0,0 +1,198 @@
+# 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.INFO)
+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 * 100))
+
+        balance_minter = None
+        balance_sink = None
+        real_supply = None
+
+        for i in range(1, 101):
+            (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.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)
+            
+            real_supply = balance_sink + balance_minter
+            logg.info('period {} testing sink {} mint {} adds up to supply {} of original {} (delta {})'.format(i, balance_sink, balance_minter, real_supply, supply, supply - real_supply))
+
+        i = 100
+        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, real_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(self):
+    def test_distribution_direct(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,21 +51,23 @@ 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 / 1000000)) * (10**38)
-        demurrage = (1 - (self.tax_level / 1000000)) * (10**28)
+        demurrage = (1 - (self.tax_level / 100000)) * (10**28)
+
+        logg.debug('demurrage {}'.format(demurrage))
         supply = self.default_supply
 
-        o = c.to_redistribution(self.address, 0, demurrage, supply, 1, sender_address=self.accounts[0])
+        o = c.to_redistribution(self.address, 0, demurrage, supply, 2, 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 / 1000000)
+        expected_distribution = (self.default_supply * self.tax_level) / 100000
+        logg.debug('distribution {} supply {}'.format(distribution, self.default_supply))
         self.assert_within_lower(distribution, expected_distribution, 1000)
 
 
-    def test_single_step(self):
+    def test_single_step_basic(self):
         nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
         c = DemurrageToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
 
@@ -81,6 +83,12 @@ 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)
@@ -169,15 +177,13 @@ 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)
         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/DemurrageTokenSingleCap.sol

@@ -128,6 +128,12 @@ contract DemurrageTokenSingleCap {
 		minimumParticipantSpend = 10 ** uint256(_decimals);
 	}
 
+	// Change sink address for redistribution
+	function setSinkAddress(address _sinkAddress) public {
+		require(msg.sender == owner);
+		sinkAddress = _sinkAddress;
+	}
+
 	// Given address will be allowed to call the mintTo() function
 	function addMinter(address _minter) public returns (bool) {
 		require(msg.sender == owner);
@@ -311,6 +317,10 @@ contract DemurrageTokenSingleCap {
 
 	// Calculate and cache the demurrage value corresponding to the (period of the) time of the method call
 	function applyDemurrage() public returns (bool) {
+		return applyDemurrageLimited(0);
+	}
+
+	function applyDemurrageLimited(uint256 _rounds) public returns (bool) {
 		//uint128 epochPeriodCount;
 		uint256 periodCount;
 		uint256 lastDemurrageAmount;
@@ -323,6 +333,12 @@ contract DemurrageTokenSingleCap {
 			return false;
 		}
 		lastDemurrageAmount = demurrageAmount;
+		// safety limit for exponential calculation to ensure that we can always
+		// execute this code no matter how much time passes.			
+		if (_rounds > 0 && _rounds < periodCount) {
+			periodCount = _rounds;
+		}
+
 		demurrageAmount = uint128(decayBy(lastDemurrageAmount, periodCount));
 		//demurragePeriod = epochPeriodCount; 
 		demurrageTimestamp = demurrageTimestamp + (periodCount * 60);

solidity/DemurrageTokenSingleNocap.sol

@@ -1,18 +1,15 @@
-pragma solidity > 0.6.11;
+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 << 20) - 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;
@@ -20,8 +17,6 @@ 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;
 
@@ -40,10 +35,17 @@ contract DemurrageTokenSingleCap {
 	uint256 public decimals;
 
 	// Implements ERC20
-	uint256 public totalSupply;
+	//uint256 public totalSupply;
+	uint256 supply;
 
-	// Minimum amount of (demurraged) tokens an account must spend to participate in redistribution for a particular period
-	uint256 public minimumParticipantSpend;
+	// 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;
 
 	// 128 bit resolution of the demurrage divisor
 	// (this constant x 1000000 is contained within 128 bits)
@@ -71,7 +73,7 @@ contract DemurrageTokenSingleCap {
 	mapping (address => mapping (address => uint256 ) ) allowance; // holder -> spender -> amount (amount is subject to demurrage)
 
 	// Address to send unallocated redistribution tokens
-	address sinkAddress; 
+	address public sinkAddress; 
 
 	// Implements ERC20
 	event Transfer(address indexed _from, address indexed _to, uint256 _value);
@@ -94,10 +96,15 @@ 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
 
 	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;
@@ -111,17 +118,20 @@ contract DemurrageTokenSingleCap {
 		demurrageTimestamp = block.timestamp;
 		periodStart = demurrageTimestamp;
 		periodDuration = _periodMinutes * 60;
-		//demurrageAmount = 100000000000000000000000000000000000000 - _taxLevelMinute; // Represents 38 decimal places, same as resolutionFactor
-		//demurrageAmount = 100000000000000000000000000000000000000;
-		demurrageAmount = 10000000000000000000000000000;
-		//demurragePeriod = 1;
+		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
 		sinkAddress = _defaultSinkAddress;
-		minimumParticipantSpend = 10 ** uint256(_decimals);
+	}
+
+
+	// Change sink address for redistribution
+	function setSinkAddress(address _sinkAddress) public {
+		require(msg.sender == owner);
+		sinkAddress = _sinkAddress;
 	}
 
 	// Given address will be allowed to call the mintTo() function
@@ -146,10 +156,8 @@ 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);
@@ -204,7 +212,7 @@ contract DemurrageTokenSingleCap {
 
 		changePeriod();
 		baseAmount = toBaseAmount(_amount);
-		totalSupply += _amount;
+		supply += _amount;
 		increaseBaseBalance(_beneficiary, baseAmount);
 		emit Mint(msg.sender, _beneficiary, _amount);
 		saveRedistributionSupply();
@@ -212,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;
@@ -244,16 +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 = growBy(totalSupply, 1);
-		grownSupply = totalSupply;
-		currentRedistribution = uint256(redistributions[redistributions.length-1]);
-		currentRedistribution &= (~maskRedistributionValue);
-		currentRedistribution |= (grownSupply << shiftRedistributionValue);
+		grownSupply = totalSupply();
+		currentRedistribution = redistributions[redistributions.length-1];
+		currentRedistribution.value = uint72(grownSupply);
 
-		redistributions[redistributions.length-1] = bytes32(currentRedistribution);
+		redistributions[redistributions.length-1] = currentRedistribution;
 		return true;
 	}
 
@@ -262,15 +269,16 @@ contract DemurrageTokenSingleCap {
 		return uint128((block.timestamp - periodStart) / periodDuration + 1);
 	}
 
-	// Add an entered demurrage period to the redistribution array
-	function checkPeriod() private view returns (bytes32) {
-		bytes32 lastRedistribution;
+	// Retrieve next redistribution if the period threshold has been crossed
+	function checkPeriod() private view returns (redistributionItem memory) {
+		redistributionItem memory lastRedistribution;
+		redistributionItem memory emptyRedistribution;
 		uint256 currentPeriod;
 
-		lastRedistribution =  redistributions[redistributions.length-1];
+		lastRedistribution =  redistributions[lastPeriod];
 		currentPeriod = this.actualPeriod();
 		if (currentPeriod <= toRedistributionPeriod(lastRedistribution)) {
-			return bytes32(0x00);
+			return emptyRedistribution;
 		}
 		return lastRedistribution;
 	}
@@ -278,11 +286,11 @@ contract DemurrageTokenSingleCap {
 	function getDistribution(uint256 _supply, uint256 _demurrageAmount) public view returns (uint256) {
 		uint256 difference;
 
-		difference = _supply * (resolutionFactor - _demurrageAmount); //(nanoDivider - ((resolutionFactor - _demurrageAmount) / nanoDivider));
+		difference = _supply * (resolutionFactor - (_demurrageAmount * 10000000000));
 		return difference / resolutionFactor;
 	}
 
-	function getDistributionFromRedistribution(bytes32 _redistribution) public returns (uint256) {
+	function getDistributionFromRedistribution(redistributionItem memory _redistribution) public returns (uint256) {
 		uint256 redistributionSupply;
 		uint256 redistributionDemurrage;
 
@@ -292,11 +300,15 @@ 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;
 	
 		unit = getDistributionFromRedistribution(_redistribution);	
-		increaseBaseBalance(sinkAddress, toBaseAmount(unit));
+		baseUnit = toBaseAmount(unit) - totalSink;
+		increaseBaseBalance(sinkAddress, baseUnit);
+		lastPeriod += 1;
+		totalSink += baseUnit;
 		return unit;
 	}
 
@@ -307,18 +319,25 @@ contract DemurrageTokenSingleCap {
 
 	// Calculate and cache the demurrage value corresponding to the (period of the) time of the method call
 	function applyDemurrage() public returns (bool) {
-		//uint128 epochPeriodCount;
+		return applyDemurrageLimited(0);
+	}
+
+	function applyDemurrageLimited(uint256 _rounds) public returns (bool) {
 		uint256 periodCount;
 		uint256 lastDemurrageAmount;
 
-		//epochPeriodCount = actualPeriod();
-		//periodCount = epochPeriodCount - demurragePeriod;
-
 		periodCount = getMinutesDelta(demurrageTimestamp);
 		if (periodCount == 0) {
 			return false;
 		}
 		lastDemurrageAmount = demurrageAmount;
+	
+		// safety limit for exponential calculation to ensure that we can always
+		// execute this code no matter how much time passes.			
+		if (_rounds > 0 && _rounds < periodCount) {
+			periodCount = _rounds;
+		}
+
 		demurrageAmount = uint128(decayBy(lastDemurrageAmount, periodCount));
 		//demurragePeriod = epochPeriodCount; 
 		demurrageTimestamp = demurrageTimestamp + (periodCount * 60);
@@ -336,37 +355,46 @@ 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 currentDemurrageAmount;
+		uint256 lastDemurrageAmount;
 		uint256 nextRedistributionDemurrage;
 		uint256 demurrageCounts;
-		uint256 periodTimestamp;
 		uint256 nextPeriod;
 
 		applyDemurrage();
 		currentRedistribution = checkPeriod();
-		if (currentRedistribution == bytes32(0x00)) {
+		if (isEmptyRedistribution(currentRedistribution)) {
 			return false;
 		}
 
+		// calculate the decay from previous redistributino
+		lastRedistribution = redistributions[lastPeriod];
 		currentPeriod = toRedistributionPeriod(currentRedistribution);
 		nextPeriod = currentPeriod + 1;
-		periodTimestamp = getPeriodTimeDelta(currentPeriod);
-
-		currentDemurrageAmount = demurrageAmount; 
-
-		demurrageCounts = demurrageCycles(periodTimestamp);
-		if (demurrageCounts > 0) {
-			nextRedistributionDemurrage = growBy(currentDemurrageAmount, demurrageCounts);
-		} else {
-			nextRedistributionDemurrage = currentDemurrageAmount;
-		}
-		
-		nextRedistribution = toRedistribution(0, nextRedistributionDemurrage, totalSupply, nextPeriod);
+		lastDemurrageAmount = toRedistributionDemurrageModifier(lastRedistribution);
+		demurrageCounts = periodDuration / 60;
+		nextRedistributionDemurrage = decayBy(lastDemurrageAmount, demurrageCounts);
+	
+		nextRedistribution = toRedistribution(0, nextRedistributionDemurrage, totalSupply(), nextPeriod);
 		redistributions.push(nextRedistribution);
 
 		applyDefaultRedistribution(nextRedistribution);
@@ -375,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) {
@@ -404,7 +432,6 @@ 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);
 	}
 
@@ -412,14 +439,45 @@ contract DemurrageTokenSingleCap {
 	function approve(address _spender, uint256 _value) public returns (bool) {
 		uint256 baseValue;
 
+		if (allowance[msg.sender][_spender] > 0) {
+			require(_value == 0, 'ZERO_FIRST');
+		}
+		
 		changePeriod();
 
 		baseValue = toBaseAmount(_value);
-		allowance[msg.sender][_spender] += baseValue;
+		allowance[msg.sender][_spender] = baseValue;
 		emit Approval(msg.sender, _spender, _value);
 		return true;
 	}
 
+	// Reduce allowance by amount
+	function decreaseAllowance(address _spender, uint256 _value) public returns (bool) {
+		uint256 baseValue;
+
+		baseValue = toBaseAmount(_value);
+		require(allowance[msg.sender][_spender] >= baseValue);
+		
+		changePeriod();
+
+		allowance[msg.sender][_spender] -= baseValue;
+		emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
+		return true;
+	}
+
+	// Increase allowance by amount
+	function increaseAllowance(address _spender, uint256 _value) public returns (bool) {
+		uint256 baseValue;
+
+		changePeriod();
+
+		baseValue = toBaseAmount(_value);
+
+		allowance[msg.sender][_spender] += baseValue;
+		emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
+		return true;
+	}
+
 	// Implements ERC20, triggers tax and/or redistribution
 	function transfer(address _to, uint256 _value) public returns (bool) {
 		uint256 baseValue;
@@ -443,7 +501,9 @@ contract DemurrageTokenSingleCap {
 		baseValue = toBaseAmount(_value);
 		require(allowance[_from][msg.sender] >= baseValue);
 
+		allowance[_from][msg.sender] -= baseValue;
 		result = transferBase(_from, _to, baseValue);
+
 		emit Transfer(_from, _to, _value);
 		return result;
 	}
@@ -455,7 +515,6 @@ contract DemurrageTokenSingleCap {
 		decreaseBaseBalance(_from, _value);
 		increaseBaseBalance(_to, _value);
 
-		//period = actualPeriod();
 		return true;
 	}
 
@@ -476,6 +535,29 @@ contract DemurrageTokenSingleCap {
 		emit OwnershipTransferred(oldOwner, owner);
 	}
 
+	// Explicitly and irretrievably burn tokens
+	// Only token minters can 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

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
@@ -33,6 +33,7 @@ test: all
 	python ../python/tests/test_pure.py
 
 install: all
-	cp -v DemurrageToken*.{json,bin} ../python/erc20_demurrage_token/data/
+	cp -v DemurrageToken*.json ../python/erc20_demurrage_token/data/
+	cp -v DemurrageToken*.bin ../python/erc20_demurrage_token/data/
 	
 .PHONY: test install