def test_token_init(chain, web3, wallet_address, get_token_contract, proxy_contract, decimals): (A, B, C, D, E) = web3.eth.accounts[:5] auction = proxy_contract multiplier = 10**(decimals) initial_supply = 5000 * multiplier # Transaction fails when auction address is invalid with pytest.raises(TypeError): token = get_token_contract([0, wallet_address, initial_supply], {'from': E}, decimals=decimals) with pytest.raises(TypeError): token = get_token_contract( [proxy_contract.address, 0, wallet_address, initial_supply], {'from': E}, decimals=decimals) with pytest.raises(TypeError): token = get_token_contract( [fake_address, wallet_address, initial_supply], {'from': E}, decimals=decimals) # Test max uint - 2 as supply (has to be even) token = get_token_contract( [proxy_contract.address, wallet_address, MAX_UINT - 1], {'from': E}, decimals=decimals) with pytest.raises(TypeError): token = get_token_contract( [proxy_contract.address, wallet_address, MAX_UINT + 1], {'from': E}, decimals=decimals) # Transaction fails if initial_supply == 0 with pytest.raises(tester.TransactionFailed): token = get_token_contract([proxy_contract.address, wallet_address, 0], {'from': E}, decimals=decimals) with pytest.raises(TypeError): token = get_token_contract( [proxy_contract.address, wallet_address, -2], {'from': E}, decimals=decimals) # Fails when supply is an odd number; auction and wallet addresses # are assigned a different number of tokens with pytest.raises(tester.TransactionFailed): token = get_token_contract([ proxy_contract.address, wallet_address, 10000001, ], {'from': E}, decimals=decimals) token = get_token_contract( [proxy_contract.address, wallet_address, initial_supply], {'from': E}, decimals=decimals) assert token.call().decimals() == decimals
def test_token_allowance(web3, wallet_address, get_bidders, get_token_contract, proxy_contract, decimals): (A, B) = get_bidders(2) multiplier = 10**(decimals) token = get_token_contract( [proxy_contract.address, wallet_address, 5000 * multiplier], decimals=decimals) assert token.call().decimals() == decimals token.transact({'from': wallet_address}).transfer(A, 3000) token.transact({'from': wallet_address}).transfer(B, 2000) with pytest.raises(TypeError): token.call().allowance(0, B) with pytest.raises(TypeError): token.call().allowance(fake_address, B) with pytest.raises(TypeError): token.call().allowance(A, 0) with pytest.raises(TypeError): token.call().allowance(A, fake_address) assert token.call().allowance(A, B) == 0 assert token.call().allowance(B, A) == 0 token.transact({'from': A}).approve(B, 300) assert token.call().allowance(A, B) == 300
def test_token_transfer(chain, web3, wallet_address, get_bidders, get_token_contract, token_contract, proxy_contract, proxy_erc223_contract, decimals, event_handler): (A, B, C) = get_bidders(3) multiplier = 10**(decimals) token = get_token_contract([ proxy_contract.address, wallet_address, 5000 * multiplier, ], decimals=decimals) assert token.call().decimals() == decimals token.transact({'from': wallet_address}).transfer(A, 3000) token.transact({'from': wallet_address}).transfer(B, 2000) token.transact({'from': wallet_address}).transfer(C, 1000) transfer_tests((A, B, C), [3000, 2000, 1000], multiplier, token, event_handler) token_erc223 = token_contract(proxy_erc223_contract.address) token_erc223.transact({'from': wallet_address}).transfer(A, 3000) token_erc223.transact({'from': wallet_address}).transfer(B, 2000) token_erc223.transact({'from': wallet_address}).transfer(C, 1000) transfer_erc223_tests((A, B, C), [3000, 2000, 1000], multiplier, token, proxy_contract, token_erc223, proxy_erc223_contract, event_handler)
def test_burn(chain, web3, wallet_address, get_bidders, get_token_contract, proxy_contract, decimals, txnCost, event_handler): decimals = 18 eth = web3.eth (A, B) = get_bidders(2) multiplier = 10**(decimals) initial_supply = 5000 * multiplier token = get_token_contract( [proxy_contract.address, wallet_address, initial_supply], decimals=decimals) assert token.call().decimals() == decimals ev_handler = event_handler(token) token.transact({'from': wallet_address}).transfer(A, 3000) token.transact({'from': wallet_address}).transfer(B, 2000) with pytest.raises(TypeError): token.transact({'from': B}).burn(-3) with pytest.raises(TypeError): token.transact({'from': B}).burn(MAX_UINT + 1) with pytest.raises(tester.TransactionFailed): token.transact({'from': B}).burn(0) with pytest.raises(tester.TransactionFailed): token.transact({'from': B}).burn(2000 + 1) # Balance should not change besides transaction costs tokens_B = token.call().balanceOf(B) balance_B = eth.getBalance(B) burnt = 250 txn_hash = token.transact({'from': B}).burn(burnt) txn_cost = txnCost(txn_hash) ev_handler.add(txn_hash, token_events['burn']) assert token.call().totalSupply() == initial_supply - burnt assert token.call().balanceOf(B) == tokens_B - burnt assert balance_B == eth.getBalance(B) + txn_cost tokens_B = token.call().balanceOf(B) balance_B = eth.getBalance(B) total_supply = token.call().totalSupply() txn_hash = token.transact({'from': B}).burn(tokens_B) txn_cost = txnCost(txn_hash) assert token.call().totalSupply() == total_supply - tokens_B assert token.call().balanceOf(B) == 0 assert balance_B == eth.getBalance(B) + txn_cost ev_handler.check()
def test_token_variable_access(chain, web3, wallet_address, get_token_contract, proxy_contract, decimals): owner = web3.eth.coinbase (A, B, C) = web3.eth.accounts[1:4] multiplier = 10**(decimals) initial_supply = 3000 * multiplier token = get_token_contract( [proxy_contract.address, wallet_address, initial_supply], {'from': owner}, decimals=decimals) assert token.call().name() == 'Raiden Token' assert token.call().symbol() == 'RDN' assert token.call().decimals() == decimals assert token.call().totalSupply() == initial_supply
def test_token_approve(web3, wallet_address, get_token_contract, proxy_contract, decimals, event_handler): (A, B, C) = web3.eth.accounts[1:4] multiplier = 10**(decimals) token = get_token_contract( [proxy_contract.address, wallet_address, 5000 * multiplier], decimals=decimals) assert token.call().decimals() == decimals ev_handler = event_handler(token) token.transact({'from': wallet_address}).transfer(A, 3000) token.transact({'from': wallet_address}).transfer(B, 2000) token.transact({'from': wallet_address}).transfer(C, 1000) with pytest.raises(TypeError): token.transact({'from': A}).approve(0, B) with pytest.raises(TypeError): token.transact({'from': A}).approve(fake_address, B) with pytest.raises(TypeError): token.transact({'from': A}).approve(B, -3) # We can approve more than we have # with pytest.raises(tester.TransactionFailed): txn_hash = token.transact({'from': A}).approve(B, 3000 + 1) ev_handler.add(txn_hash, token_events['approve']) txn_hash = token.transact({'from': A}).approve(A, 300) ev_handler.add(txn_hash, token_events['approve']) assert token.call().allowance(A, A) == 300 with pytest.raises(tester.TransactionFailed): txn_hash = token.transact({'from': A}).approve(B, 300) txn_hash = token.transact({'from': A}).approve(B, 0) txn_hash = token.transact({'from': A}).approve(B, 300) ev_handler.add(txn_hash, token_events['approve']) txn_hash = token.transact({'from': B}).approve(C, 650) ev_handler.add(txn_hash, token_events['approve']) assert token.call().allowance(A, B) == 300 assert token.call().allowance(B, C) == 650 ev_handler.check()
def test_token_transfer_from(chain, web3, wallet_address, get_bidders, get_token_contract, proxy_contract, decimals, event_handler): (A, B, C) = get_bidders(3) multiplier = 10**(decimals) token = get_token_contract( [proxy_contract.address, wallet_address, 5000 * multiplier], decimals=decimals) assert token.call().decimals() == decimals ev_handler = event_handler(token) token.transact({'from': wallet_address}).transfer(A, 3000) token.transact({'from': wallet_address}).transfer(B, 2000) token.transact({'from': wallet_address}).transfer(C, 1000) txn_hash = token.transact({'from': B}).approve(A, 300) ev_handler.add(txn_hash, token_events['approve']) assert token.call().allowance(B, A) == 300 with pytest.raises(TypeError): token.transact({'from': A}).transferFrom(0, C, 10) with pytest.raises(TypeError): token.transact({'from': A}).transferFrom(B, 0, 10) with pytest.raises(TypeError): token.transact({'from': A}).transferFrom(fake_address, C, 10) with pytest.raises(TypeError): token.transact({'from': A}).transferFrom(B, fake_address, 10) with pytest.raises(TypeError): token.transact({'from': A}).transferFrom(B, C, MAX_UINT + 1) with pytest.raises(TypeError): token.transact({'from': A}).transferFrom(B, C, -5) with pytest.raises(tester.TransactionFailed): allowance_B = token.call().allowance(B, A) token.transact({'from': A}).transferFrom(B, C, allowance_B + 1) # We can allow more than the balance, but we cannot transfer more with pytest.raises(tester.TransactionFailed): balance_B = token.call().balanceOf(B) token.transact({'from': B}).approve(A, balance_B + 10) token.transact({'from': A}).transferFrom(B, C, balance_B + 10) # Test for overflow with pytest.raises(tester.TransactionFailed): balance_B = token.call().balanceOf(B) overflow = MAX_UINT + 1 - balance_B token.transact({'from': B}).approve(A, overflow) token.transact({'from': A}).transferFrom(B, C, overflow) with pytest.raises(tester.TransactionFailed): txn_hash = token.transact({'from': B}).approve(A, 300) txn_hash = token.transact({'from': B}).approve(A, 0) txn_hash = token.transact({'from': B}).approve(A, 300) ev_handler.add(txn_hash, token_events['approve']) assert token.call().allowance(B, A) == 300 balance_A = token.call().balanceOf(A) balance_B = token.call().balanceOf(B) balance_C = token.call().balanceOf(C) txn_hash = token.transact({'from': A}).transferFrom(B, C, 0) ev_handler.add(txn_hash, token_events['transfer']) assert token.call().balanceOf(A) == balance_A assert token.call().balanceOf(B) == balance_B assert token.call().balanceOf(C) == balance_C txn_hash = token.transact({'from': A}).transferFrom(B, C, 150) ev_handler.add(txn_hash, token_events['transfer']) assert token.call().balanceOf(A) == balance_A assert token.call().balanceOf(B) == balance_B - 150 assert token.call().balanceOf(C) == balance_C + 150 ev_handler.check()