erc20-demurrage-token-archive/python/tests/test_redistribution.py

# standard imports
import os
import unittest
import json
import logging

# third-party imports
import web3
import eth_tester
import eth_abi

logging.basicConfig(level=logging.DEBUG)
logg = logging.getLogger()

logging.getLogger('web3').setLevel(logging.WARNING)
logging.getLogger('eth.vm').setLevel(logging.WARNING)

testdir = os.path.dirname(__file__)

#BLOCKTIME = 5 # seconds
TAX_LEVEL = 10000 * 2 # 2%
#PERIOD = int(60/BLOCKTIME) * 60 * 24 * 30 # month
PERIOD = 20


class Test(unittest.TestCase):

    contract = None

    def setUp(self):
        eth_params = eth_tester.backends.pyevm.main.get_default_genesis_params({
            'gas_limit': 9000000,
            })

        f = open(os.path.join(testdir, '../../solidity/RedistributedDemurrageToken.bin'), 'r')
        self.bytecode = f.read()
        f.close()

        f = open(os.path.join(testdir, '../../solidity/RedistributedDemurrageToken.json'), 'r')
        self.abi = json.load(f)
        f.close()

        backend = eth_tester.PyEVMBackend(eth_params)
        self.eth_tester =  eth_tester.EthereumTester(backend)
        provider = web3.Web3.EthereumTesterProvider(self.eth_tester)
        self.w3 = web3.Web3(provider)
        self.sink_address = self.w3.eth.accounts[9]

        c = self.w3.eth.contract(abi=self.abi, bytecode=self.bytecode)
        tx_hash = c.constructor('Foo Token', 'FOO', 6, TAX_LEVEL, PERIOD, self.sink_address).transact({'from': self.w3.eth.accounts[0]})

        r = self.w3.eth.getTransactionReceipt(tx_hash)
        self.contract = self.w3.eth.contract(abi=self.abi, address=r.contractAddress)

        self.start_block = self.w3.eth.blockNumber
        logg.debug('starting at block number {}'.format(self.start_block))

    def tearDown(self):
        pass


    def debug_periods(self):
        pactual = self.contract.functions.actualPeriod().call()
        pstart = self.contract.functions.periodStart().call()
        pduration = self.contract.functions.periodDuration().call()
        blocknumber = self.w3.eth.blockNumber;
        logg.debug('actual {} start {} duration {} blocknumber {}'.format(pactual, pstart, pduration, blocknumber))


    # TODO: check receipt log outputs
    @unittest.skip('foo')
    def test_redistribution_storage(self):
        self.contract.functions.mintTo(self.w3.eth.accounts[1], 2000).transact()

        tx_hash = self.contract.functions.transfer(self.w3.eth.accounts[2], 500).transact({'from': self.w3.eth.accounts[1]})
        r = self.w3.eth.getTransactionReceipt(tx_hash)
        logg.debug('tx before {}'.format(r))
        self.assertEqual(r.status, 1)

        self.eth_tester.mine_blocks(PERIOD)

        redistribution = self.contract.functions.redistributions(0).call();
        self.assertEqual(redistribution.hex(), '000000000100000000000000000000000000000000000007d000000000000001')

        tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[0], 1000000).transact()
        r = self.w3.eth.getTransactionReceipt(tx_hash)
        self.assertEqual(r.status, 1)

        redistribution = self.contract.functions.redistributions(1).call()
        self.assertEqual(redistribution.hex(), '000000000000000000000000000000000000000000000f4a1000000000000002')
    

    def test_redistribution_balance_on_zero_participants(self):
        supply = 1000000000000
        tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[1], supply).transact()
        r = self.w3.eth.getTransactionReceipt(tx_hash)

        self.eth_tester.mine_blocks(PERIOD)

        tx_hash = self.contract.functions.applyTax().transact()
        r = self.w3.eth.getTransactionReceipt(tx_hash)
        logg.debug('r {}'.format(r))
        self.assertEqual(r.status, 1)

        redistribution = self.contract.functions.redistributions(0).call();
        supply = self.contract.functions.totalSupply().call()

        sink_increment = int(supply * (TAX_LEVEL / 1000000))
        for l in r['logs']:
            if l.topics[0].hex() == '0x337db9c77a0769d770641c73e3282be23b15e2bddd830c219461dec832313389': # event Taxed(uint256,uint256)
                period = int.from_bytes(l.topics[1], 'big')
                self.assertEqual(period, 1)
                b = bytes.fromhex(l.data[2:])
                remainder = int.from_bytes(b, 'big')
                self.assertEqual(remainder, sink_increment)
                logg.debug('period {} remainder {}'.format(period, remainder))

        sink_balance = self.contract.functions.balanceOf(self.sink_address).call()
        logg.debug('{} {}'.format(sink_increment, sink_balance))
        self.assertEqual(sink_balance, int(sink_increment * 0.98))
        self.assertEqual(sink_balance, int(sink_increment * (1000000 - TAX_LEVEL) / 1000000))

        balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call()
        self.assertEqual(balance, supply - sink_increment)


    def test_redistribution_two_of_ten(self):
        mint_amount = 100000000
        z = 0
        for i in range(10):
            self.contract.functions.mintTo(self.w3.eth.accounts[i], mint_amount).transact()
            z += mint_amount

        initial_balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call()

        spend_amount = 1000000
        external_address = web3.Web3.toChecksumAddress('0x' + os.urandom(20).hex())
        self.contract.functions.transfer(external_address, spend_amount).transact({'from': self.w3.eth.accounts[1]})
        tx_hash = self.contract.functions.transfer(external_address, spend_amount).transact({'from': self.w3.eth.accounts[2]})
        r = self.w3.eth.getTransactionReceipt(tx_hash)

        self.assertEqual(r.status, 1)

        self.eth_tester.mine_blocks(PERIOD)

        self.contract.functions.applyTax().transact()

        bummer_balance = self.contract.functions.balanceOf(self.w3.eth.accounts[3]).call()
        self.assertEqual(bummer_balance, mint_amount - (mint_amount * (TAX_LEVEL / 1000000)))
        logg.debug('bal {} '.format(bummer_balance))

        bummer_balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call()
        spender_balance = mint_amount - spend_amount
        spender_decayed_balance = int(spender_balance - (spender_balance * (TAX_LEVEL / 1000000)))
        self.assertEqual(bummer_balance, spender_decayed_balance)
        logg.debug('bal {} '.format(bummer_balance))

        tx_hash = self.contract.functions.applyRedistributionOnAccount(self.w3.eth.accounts[1]).transact()
        r = self.w3.eth.getTransactionReceipt(tx_hash)
        logg.debug('log {}'.format(r.logs))

        self.contract.functions.applyRedistributionOnAccount(self.w3.eth.accounts[2]).transact()

        redistribution_data = self.contract.functions.redistributions(0).call()
        logg.debug('redist data {}'.format(redistribution_data.hex()))

        account_period_data = self.contract.functions.accountPeriod(self.w3.eth.accounts[1]).call()
        logg.debug('account period {}'.format(account_period_data))

        actual_period = self.contract.functions.actualPeriod().call()
        logg.debug('period {}'.format(actual_period))

        redistribution = int((z / 2) * (TAX_LEVEL / 1000000))
        spender_new_base_balance = ((mint_amount - spend_amount) + redistribution)
        spender_new_decayed_balance = int(spender_new_base_balance - (spender_new_base_balance * (TAX_LEVEL / 1000000)))

        spender_actual_balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call()
        logg.debug('rrr {} {}'.format(redistribution, spender_new_decayed_balance))

        self.assertEqual(spender_actual_balance, spender_new_decayed_balance)


    @unittest.skip('foo')
    def test_redistribution_balance_to_single(self):
        z = 0
        for i in range(3):
            redistribution = self.contract.functions.redistributions(0).call();
            logg.debug('foo {}'.format(redistribution.hex()))
            self.debug_periods();

            self.contract.functions.mintTo(self.w3.eth.accounts[i], 1000000*(i+1)).transact()
            z += 1000000*(i+1)

        tx_hash = self.contract.functions.transfer(self.w3.eth.accounts[3], 1000000).transact({'from': self.w3.eth.accounts[0]})
        r = self.w3.eth.getTransactionReceipt(tx_hash)
        logg.debug('tx before r {}'.format(r))

        balance = self.contract.functions.balanceOf(self.w3.eth.accounts[0]).call()
        self.assertEqual(balance, 0)

        self.eth_tester.mine_blocks(PERIOD)

        redistribution = self.contract.functions.redistributions(0).call();
        self.assertEqual(redistribution.hex(), '000000000100000000000000000000000000000000005b8d8000000000000001')

        tx_hash = self.contract.functions.transfer(self.w3.eth.accounts[3], 0).transact({'from': self.w3.eth.accounts[0]})
        r = self.w3.eth.getTransactionReceipt(tx_hash)
        logg.debug('tx after r {}'.format(r))

        balance = self.contract.functions.balanceOf(self.w3.eth.accounts[0]).call()
        self.assertEqual(balance, int(z * 0.02 * 0.98))

        redistribution = self.contract.functions.redistributions(1).call();
        self.assertEqual(redistribution.hex(), '000000000000000000000000000000000000000000005b8d8000000000000002')


    @unittest.skip('foo')
    def test_redistribution_balance_to_two(self):
        z = 0
        for i in range(5):
            redistribution = self.contract.functions.redistributions(0).call();
            logg.debug('foo {}'.format(redistribution.hex()))
            self.debug_periods();

            self.contract.functions.mintTo(self.w3.eth.accounts[i], 1000000*(i+1)).transact()
            z += 1000000*(i+1)

        tx_hash = self.contract.functions.transfer(self.w3.eth.accounts[5], 1000000).transact({'from': self.w3.eth.accounts[0]})
        r = self.w3.eth.getTransactionReceipt(tx_hash)

        tx_hash = self.contract.functions.transfer(self.w3.eth.accounts[6], 2000000).transact({'from': self.w3.eth.accounts[1]})
        r = self.w3.eth.getTransactionReceipt(tx_hash)

        # No cheating!
        tx_hash = self.contract.functions.transfer(self.w3.eth.accounts[2], 3000000).transact({'from': self.w3.eth.accounts[2]})
        r = self.w3.eth.getTransactionReceipt(tx_hash)

        balance = self.contract.functions.balanceOf(self.w3.eth.accounts[0]).call()
        self.assertEqual(balance, 0)

        balance = self.contract.functions.balanceOf(self.w3.eth.accounts[1]).call()
        self.assertEqual(balance, 0)

        self.eth_tester.mine_blocks(PERIOD) 
        self.debug_periods();

        redistribution = self.contract.functions.redistributions(0).call();
        self.assertEqual(redistribution.hex(), '00000000020000000000000000000000000000000000e4e1c000000000000001')

        tx_hash = self.contract.functions.transfer(self.w3.eth.accounts[3], 0).transact({'from': self.w3.eth.accounts[0]})
        r = self.w3.eth.getTransactionReceipt(tx_hash)

        balance = self.contract.functions.balanceOf(self.w3.eth.accounts[0]).call()
        self.assertEqual(balance, int((z * 0.02 * 0.98) / 2))

        redistribution = self.contract.functions.redistributions(1).call();
        self.assertEqual(redistribution.hex(), '00000000000000000000000000000000000000000000e4e1c000000000000002')


if __name__ == '__main__':
    unittest.main()