Move to chainlib-eth

python/CHANGELOG

@@ -0,0 +1,4 @@
+- 0.0.2-pending
+	* Move to chainlib-eth
+- 0.0.1-unreleased
+	* Interface for redistributed and non-redistributed, with or without cap

python/erc20_demurrage_token/runnable/deploy.py

@@ -70,8 +70,8 @@ if args.vv:
 elif args.v:
     logg.setLevel(logging.INFO)
 
-block_last = args.w
 block_all = args.ww
+block_last = args.w or block_all
 
 # process config
 config = confini.Config(args.c)

python/erc20_demurrage_token/sim/sim.py

@@ -200,7 +200,7 @@ class DemurrageTokenSimulation:
         else:
             o = self.caller_contract.balance_of(self.address, holder, sender_address=self.caller_address)
         r = self.rpc.do(o)
-        return self.caller_contract.parse_balance_of(r)
+        return self.caller_contract.parse_balance(r)
 
 
     def __next_block(self):

python/erc20_demurrage_token/token.py

@@ -14,7 +14,7 @@ from chainlib.eth.contract import (
         abi_decode_single,
         )
 from chainlib.eth.constant import ZERO_ADDRESS
-from chainlib.jsonrpc import jsonrpc_template
+from chainlib.jsonrpc import JSONRPCRequest
 from eth_erc20 import ERC20
 from hexathon import (
         add_0x,
@@ -70,7 +70,7 @@ class DemurrageToken(ERC20):
 
     @staticmethod
     def gas(code=None):
-        return 3500000
+        return 4000000
 
 
     @staticmethod
@@ -146,8 +146,9 @@ class DemurrageToken(ERC20):
         return tx
 
 
-    def to_base_amount(self, contract_address, value, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def to_base_amount(self, contract_address, value, sender_address=ZERO_ADDRESS, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        o = j.template()
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('toBaseAmount')
@@ -158,11 +159,13 @@ class DemurrageToken(ERC20):
         tx = self.set_code(tx, data)
         o['params'].append(self.normalize(tx))
         o['params'].append('latest')
+        o = j.finalize(o)
         return o
 
 
-    def remainder(self, contract_address, parts, whole, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def remainder(self, contract_address, parts, whole, sender_address=ZERO_ADDRESS, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        o = j.template()
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('remainder')
@@ -175,11 +178,13 @@ class DemurrageToken(ERC20):
         tx = self.set_code(tx, data)
         o['params'].append(self.normalize(tx))
         o['params'].append('latest')
+        o = j.finalize(o)
         return o
 
 
-    def redistributions(self, contract_address, idx, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def redistributions(self, contract_address, idx, sender_address=ZERO_ADDRESS, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        o = j.template()
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('redistributions')
@@ -190,11 +195,13 @@ class DemurrageToken(ERC20):
         tx = self.set_code(tx, data)
         o['params'].append(self.normalize(tx))
         o['params'].append('latest')
+        o = j.finalize(o)
         return o
 
 
-    def account_period(self, contract_address, address, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def account_period(self, contract_address, address, sender_address=ZERO_ADDRESS, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        o = j.template()
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('accountPeriod')
@@ -205,11 +212,13 @@ class DemurrageToken(ERC20):
         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(self, contract_address, participants, demurrage_modifier_ppm, value, period, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def to_redistribution(self, contract_address, participants, demurrage_modifier_ppm, value, period, sender_address=ZERO_ADDRESS, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        o = j.template()
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('toRedistribution')
@@ -226,12 +235,14 @@ class DemurrageToken(ERC20):
         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_period(self, contract_address, redistribution, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def to_redistribution_period(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('toRedistributionPeriod')
@@ -242,11 +253,13 @@ class DemurrageToken(ERC20):
         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):
-        o = jsonrpc_template()
+    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')
@@ -257,11 +270,13 @@ class DemurrageToken(ERC20):
         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):
-        o = jsonrpc_template()
+    def to_redistribution_supply(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('toRedistributionSupply')
@@ -272,11 +287,13 @@ class DemurrageToken(ERC20):
         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_demurrage_modifier(self, contract_address, redistribution, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def to_redistribution_demurrage_modifier(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('toRedistributionDemurrageModifier')
@@ -287,11 +304,13 @@ class DemurrageToken(ERC20):
         tx = self.set_code(tx, data)
         o['params'].append(self.normalize(tx))
         o['params'].append('latest')
+        o = j.finalize(o)
         return o
 
 
-    def base_balance_of(self, contract_address, address, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def base_balance_of(self, contract_address, address, sender_address=ZERO_ADDRESS, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        o = j.template()
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('baseBalanceOf')
@@ -302,6 +321,7 @@ class DemurrageToken(ERC20):
         tx = self.set_code(tx, data)
         o['params'].append(self.normalize(tx))
         o['params'].append('latest')
+        o = j.finalize(o)
         return o
 
 
@@ -345,8 +365,9 @@ 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):
-        o = jsonrpc_template()
+    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')
@@ -359,11 +380,13 @@ class DemurrageToken(ERC20):
         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):
-        o = jsonrpc_template()
+    def decay_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('decayBy')
@@ -376,11 +399,13 @@ class DemurrageToken(ERC20):
         tx = self.set_code(tx, data)
         o['params'].append(self.normalize(tx))
         o['params'].append('latest')
+        o = j.finalize(o)
         return o
 
 
-    def get_distribution(self, contract_address, supply, demurrage_amount, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def get_distribution(self, contract_address, supply, demurrage_amount, sender_address=ZERO_ADDRESS, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        o = j.template()
         o['method'] = 'eth_call'
         enc = ABIContractEncoder()
         enc.method('getDistribution')
@@ -393,11 +418,13 @@ class DemurrageToken(ERC20):
         tx = self.set_code(tx, data)
         o['params'].append(self.normalize(tx))
         o['params'].append('latest')
+        o = j.finalize(o)
         return o
 
 
-    def get_distribution_from_redistribution(self, contract_address, redistribution, sender_address=ZERO_ADDRESS):
-        o = jsonrpc_template()
+    def get_distribution_from_redistribution(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('getDistributionFromRedistribution')
@@ -408,6 +435,7 @@ class DemurrageToken(ERC20):
         tx = self.set_code(tx, data)
         o['params'].append(self.normalize(tx))
         o['params'].append('latest')
+        o = j.finalize(o)
         return o
 
 

python/examples/sim_noredistribute.py

@@ -17,9 +17,10 @@ settings.symbol = 'SIM'
 settings.decimals = 6
 settings.demurrage_level = int(decay_per_minute*(10**38))
 #settings.period_minutes = 1 # 1 week in minutes
-settings.period_minutes = 10
+settings.period_minutes = 60*24*7
 chain = 'evm:foochain:42'
 cap = (10 ** 6) * (10 ** 12)
+#cap = 0
 
 # instantiate simulation
 sim = DemurrageTokenSimulation(chain, settings, redistribute=False, cap=cap, actors=10)

python/requirements.txt

@@ -1,3 +1,3 @@
-chainlib~=0.0.3rc3
-eth-erc20~=0.0.9a4
-crypto-dev-signer~=0.4.14b3
+chainlib~=0.0.5a1
+eth-erc20~=0.0.10a1
+crypto-dev-signer~=0.4.14b6

python/setup.cfg

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

python/test.sh

@@ -7,10 +7,16 @@ export PYTHONPATH=.
 #modes=(MultiNocap MultiCap SingleCap SingleNocap)
 modes=(SingleCap SingleNocap) # other contracts need to be updted
 for m in ${modes[@]}; do
-	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_period.py
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_basic.py
 	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
+done
+
+modes=(SingleCap) # other contracts need to be updted
+for m in ${modes[@]}; do
+	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_period.py
+	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_redistribution_unit.py
 done
 
 modes=(MultiCap SingleCap)
@@ -18,12 +24,6 @@ for m in ${modes[@]}; do
 	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_cap.py
 done
 
-modes=(SingleCap SingleNocap)
-for m in ${modes[@]}; do
-	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_single.py
-	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_redistribution_unit.py
-done
-
 #modes=(MultiCap MultiNocap)
 #for m in ${modes[@]}; do
 #	ERC20_DEMURRAGE_TOKEN_TEST_MODE=$m python tests/test_remainder.py

python/test_requirements.txt

@@ -1,3 +1,2 @@
-#web3==5.12.2
 eth_tester==0.5.0b3
 py-evm==0.3.0a20

python/tests/test_amounts.py

@@ -35,7 +35,7 @@ class TestAmounts(TestDemurrageDefault):
         
         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)
+        balance = c.parse_balance(r)
         self.assertEqual(balance, 817)
 
         (tx_hash, o) = c.mint_to(self.address, self.accounts[0], self.accounts[1], 1000)
@@ -43,7 +43,7 @@ class TestAmounts(TestDemurrageDefault):
 
         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)
+        balance = c.parse_balance(r)
         self.assert_within_lower(balance, 1817, 750)
 
         self.backend.time_travel(self.start_time + self.period_seconds * 2)
@@ -53,7 +53,7 @@ class TestAmounts(TestDemurrageDefault):
         
         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)
+        balance = c.parse_balance(r)
 
         expected_balance = ((1 - self.tax_level / 1000000) ** 10) * 1000
         expected_balance += ((1 - self.tax_level / 1000000) ** 20) * 1000
@@ -73,7 +73,7 @@ class TestAmounts(TestDemurrageDefault):
  
         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)
+        balance = c.parse_balance(r)
         self.assertEqual(balance, 1634)
 
         nonce_oracle = RPCNonceOracle(self.accounts[1], self.rpc)
@@ -83,12 +83,12 @@ class TestAmounts(TestDemurrageDefault):
      
         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)
+        balance = c.parse_balance(r)
         self.assertEqual(balance, 1134)
 
         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)
+        balance = c.parse_balance(r)
         self.assert_within_lower(balance, 500, 2000)
 
 
@@ -115,7 +115,7 @@ class TestAmounts(TestDemurrageDefault):
 
             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)
+            balance = c.parse_balance(r)
             self.assertEqual(balance, case[1])
 
 

python/tests/test_period.py

@@ -70,10 +70,10 @@ class TestPeriod(TestDemurrageDefault):
         # allow test code float rounding error to billionth
         modifier = (1 - (self.tax_level / 1000000)) ** (self.period_seconds / 60)
         modifier *= 10 ** 9 
-        modifier = int(modifier) * (10 ** (38 - 9))
+        modifier = int(modifier) * (10 ** (28 - 9))
 
-        period /= (10 ** (38 - 9))
-        period = int(period) * (10 ** (38 - 9))
+        period /= (10 ** (28 - 9))
+        period = int(period) * (10 ** (28 - 9))
         self.assertEqual(modifier, period)
 
         self.backend.time_travel(self.start_time + self.period_seconds * 2)
@@ -96,10 +96,10 @@ class TestPeriod(TestDemurrageDefault):
         # allow test code float rounding error to billionth
         modifier = (1 - (self.tax_level / 1000000)) ** ((self.period_seconds * 2) / 60)
         modifier *= 10 ** 9 
-        modifier = int(modifier) * (10 ** (38 - 9))
+        modifier = int(modifier) * (10 ** (28 - 9))
 
-        period /= (10 ** (38 - 9))
-        period = int(period) * (10 ** (38 - 9))
+        period /= (10 ** (28 - 9))
+        period = int(period) * (10 ** (28 - 9))
         self.assertEqual(modifier, period)
 
 

python/tests/test_redistribution_unit.py

@@ -36,21 +36,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**38)
+        demurrage = (1 - (self.tax_level / 1000000)) * (10**28)
         supply = self.default_supply
 
         o = c.get_distribution(self.address, supply, demurrage, sender_address=self.accounts[0])
         r = self.rpc.do(o)
         distribution = c.parse_get_distribution(r)
         expected_distribution = self.default_supply * (self.tax_level / 1000000)
-        self.assertEqual(distribution, expected_distribution)
+        self.assert_within_lower(distribution, expected_distribution, 1000)
 
 
     def test_distribution_from_redistribution(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**38)
+        demurrage = (1 - (self.tax_level / 1000000)) * (10**28)
         supply = self.default_supply
 
         o = c.to_redistribution(self.address, 0, demurrage, supply, 1, sender_address=self.accounts[0])
@@ -60,8 +62,7 @@ class TestRedistribution(TestDemurrageUnit):
         r = self.rpc.do(o)
         distribution = c.parse_get_distribution(r)
         expected_distribution = self.default_supply * (self.tax_level / 1000000)
-        self.assertEqual(distribution, expected_distribution)
-
+        self.assert_within_lower(distribution, expected_distribution, 1000)
 
 
     def test_single_step(self):
@@ -82,7 +83,7 @@ class TestRedistribution(TestDemurrageUnit):
 
         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)
+        balance = c.parse_balance(r)
 
         self.assertEqual(balance, expected_balance)
 
@@ -107,7 +108,7 @@ class TestRedistribution(TestDemurrageUnit):
         for i in range(3):
             o = c.balance_of(self.address, self.accounts[i+1], sender_address=self.accounts[0])
             r = self.rpc.do(o)
-            balance = c.parse_balance_of(r)
+            balance = c.parse_balance(r)
             self.assertEqual(balance, expected_balance)
 
 
@@ -146,7 +147,7 @@ class TestRedistribution(TestDemurrageUnit):
         expected_balance = mint_amount - demurrage_amount
         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)
+        balance = c.parse_balance(r)
         self.assertEqual(balance, expected_balance)
 
         half_demurrage_amount = int((self.tax_level / 1000000) * half_mint_amount)
@@ -154,12 +155,12 @@ class TestRedistribution(TestDemurrageUnit):
         expected_balance = half_mint_amount - half_demurrage_amount
         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)
+        balance = c.parse_balance(r)
         self.assertEqual(balance, expected_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)
+        balance = c.parse_balance(r)
         self.assertEqual(balance, expected_balance)
 
         o = c.total_supply(self.address, sender_address=self.accounts[0])
@@ -184,7 +185,7 @@ class TestRedistribution(TestDemurrageUnit):
 
         o = c.balance_of(self.address, self.sink_address, sender_address=self.accounts[0])
         r = self.rpc.do(o)
-        balance = c.parse_balance_of(r)
+        balance = c.parse_balance(r)
         self.assert_within_lower(balance, expected_balance, 1000)
 
 

python/tests/test_single.py

@@ -67,18 +67,18 @@ class TestRedistributionSingle(TestDemurrageSingle):
         tax_modifier = (1 - (self.tax_level / 1000000)) ** 10
         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)
+        balance = c.parse_balance(r)
         self.assertEqual(balance, int(mint_amount * tax_modifier))
 
         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)
+        balance = c.parse_balance(r)
         base_amount = mint_amount - int(mint_amount * 0.1)
         self.assertEqual(balance, int(base_amount * tax_modifier)) #(base_amount - (base_amount * (self.tax_level / 1000000))))
 
         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)
+        balance = c.parse_balance(r)
         base_amount = mint_amount - int(mint_amount * 0.2)
         self.assertEqual(balance, int(base_amount * tax_modifier)) #(base_amount - (base_amount * (self.tax_level / 1000000))))
 
@@ -88,7 +88,7 @@ class TestRedistributionSingle(TestDemurrageSingle):
 
         o = c.balance_of(self.address, self.sink_address, sender_address=self.accounts[0])
         r = self.rpc.do(o)
-        balance = c.parse_balance_of(r)
+        balance = c.parse_balance(r)
         expected_balance = new_supply - (new_supply * tax_modifier)
         self.assert_within_lower(balance, expected_balance, 1)
 

solidity/DemurrageTokenSingleCap.sol

@@ -12,7 +12,7 @@ contract DemurrageTokenSingleCap {
 	uint8 constant shiftRedistributionValue 	= 32;
 	uint256 constant maskRedistributionValue	= 0x00000000000000000000000000000000000000ffffffffffffffffff00000000; // ((1 << 72) - 1) << 32
 	uint8 constant shiftRedistributionDemurrage	= 104;
-	uint256 constant maskRedistributionDemurrage	= 0x000000ffffffffffffffffffffffffffffffff00000000000000000000000000; // ((1 << 20) - 1) << 140
+	uint256 constant maskRedistributionDemurrage	= 0x0000000000ffffffffffffffffffffffffffff00000000000000000000000000; // ((1 << 20) - 1) << 140
 
 	// Account balances
 	mapping (address => uint256) account;
@@ -115,7 +115,8 @@ contract DemurrageTokenSingleCap {
 		periodStart = demurrageTimestamp;
 		periodDuration = _periodMinutes * 60;
 		//demurrageAmount = 100000000000000000000000000000000000000 - _taxLevelMinute; // Represents 38 decimal places, same as resolutionFactor
-		demurrageAmount = 100000000000000000000000000000000000000;
+		//demurrageAmount = 100000000000000000000000000000000000000;
+		demurrageAmount = 10000000000000000000000000000;
 		//demurragePeriod = 1;
 		taxLevel = _taxLevelMinute; // Represents 38 decimal places
 		bytes32 initialRedistribution = toRedistribution(0, demurrageAmount, 0, 1);
@@ -152,7 +153,7 @@ contract DemurrageTokenSingleCap {
 		//periodCount = actualPeriod() - demurragePeriod; 
 		periodCount = getMinutesDelta(demurrageTimestamp);
 
-		currentDemurragedAmount = uint128(decayBy(demurrageAmount, periodCount));
+		currentDemurragedAmount = uint128(decayBy(demurrageAmount * 10000000000, periodCount));
 
 		return (baseBalance * currentDemurragedAmount) / (nanoDivider * 1000000000000);
 	}
@@ -281,7 +282,7 @@ 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)); //(nanoDivider - ((resolutionFactor - _demurrageAmount) / nanoDivider));
 		return difference / resolutionFactor;
 	}
 
@@ -407,7 +408,7 @@ contract DemurrageTokenSingleCap {
 
 	// Inflates the given amount according to the current demurrage modifier
 	function toBaseAmount(uint256 _value) public view returns (uint256) {
-		return (_value * resolutionFactor) / demurrageAmount;
+		return (_value * resolutionFactor) / (demurrageAmount * 10000000000);
 	}
 
 	// Implements ERC20, triggers tax and/or redistribution

solidity/DemurrageTokenSingleNocap.sol

@@ -12,11 +12,7 @@ contract DemurrageTokenSingleCap {
 	uint8 constant shiftRedistributionValue 	= 32;
 	uint256 constant maskRedistributionValue	= 0x00000000000000000000000000000000000000ffffffffffffffffff00000000; // ((1 << 72) - 1) << 32
 	uint8 constant shiftRedistributionDemurrage	= 104;
-	uint256 constant maskRedistributionDemurrage	= 0x000000ffffffffffffffffffffffffffffffff00000000000000000000000000; // ((1 << 20) - 1) << 140
-
-	uint8 constant shiftRedistributionIsUsed	= 255;
-	uint256 constant maskRedistributionIsUsed	= 0x4000000000000000000000000000000000000000000000000000000000000000; // 1 << 255
-
+	uint256 constant maskRedistributionDemurrage	= 0x0000000000ffffffffffffffffffffffffffff00000000000000000000000000; // ((1 << 20) - 1) << 140
 
 	// Account balances
 	mapping (address => uint256) account;
@@ -116,7 +112,8 @@ contract DemurrageTokenSingleCap {
 		periodStart = demurrageTimestamp;
 		periodDuration = _periodMinutes * 60;
 		//demurrageAmount = 100000000000000000000000000000000000000 - _taxLevelMinute; // Represents 38 decimal places, same as resolutionFactor
-		demurrageAmount = 100000000000000000000000000000000000000;
+		//demurrageAmount = 100000000000000000000000000000000000000;
+		demurrageAmount = 10000000000000000000000000000;
 		//demurragePeriod = 1;
 		taxLevel = _taxLevelMinute; // Represents 38 decimal places
 		bytes32 initialRedistribution = toRedistribution(0, demurrageAmount, 0, 1);
@@ -152,7 +149,8 @@ contract DemurrageTokenSingleCap {
 		//periodCount = actualPeriod() - demurragePeriod; 
 		periodCount = getMinutesDelta(demurrageTimestamp);
 
-		currentDemurragedAmount = uint128(decayBy(demurrageAmount, periodCount));
+		//currentDemurragedAmount = uint128(decayBy(demurrageAmount, periodCount));
+		currentDemurragedAmount = uint128(decayBy(demurrageAmount * 10000000000, periodCount));
 
 		return (baseBalance * currentDemurragedAmount) / (nanoDivider * 1000000000000);
 	}
@@ -406,7 +404,8 @@ 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;
+		return (_value * resolutionFactor) / (demurrageAmount * 10000000000);
 	}
 
 	// Implements ERC20, triggers tax and/or redistribution