diff --git a/populus-tests/block-scheduling/test_block_claiming.py b/populus-tests/block-scheduling/test_block_claiming.py deleted file mode 100644 index 181795616..000000000 --- a/populus-tests/block-scheduling/test_block_claiming.py +++ /dev/null @@ -1,190 +0,0 @@ -import pytest - - -def test_cannot_claim_before_first_claim_block(chain, web3, RequestData, get_claim_data): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - first_claim_block = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - - # sanity - assert first_claim_block > web3.eth.blockNumber - - chain.wait.for_block(first_claim_block - 1) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - with pytest.raises(AssertionError): - get_claim_data(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == '0x0000000000000000000000000000000000000000' - - -def test_can_claim_at_first_claim_block(chain, web3, RequestData, get_claim_data): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - first_claim_block = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - - # sanity - assert first_claim_block > web3.eth.blockNumber - - chain.wait.for_block(first_claim_block) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - claim_data = get_claim_data(claim_txn_hash) - assert claim_data - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.coinbase - - -def test_can_claim_at_last_claim_block(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - last_claim_block = request_data.schedule.windowStart - request_data.schedule.freezePeriod - 1 - - # sanity - assert last_claim_block > web3.eth.blockNumber - - chain.wait.for_block(last_claim_block) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.coinbase - - -def test_cannot_claim_after_last_claim_block(chain, web3, RequestData, get_claim_data): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - last_claim_block = request_data.schedule.windowStart - request_data.schedule.freezePeriod - - # sanity - assert last_claim_block > web3.eth.blockNumber - - chain.wait.for_block(last_claim_block) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - with pytest.raises(AssertionError): - get_claim_data(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == '0x0000000000000000000000000000000000000000' - - -def test_executing_own_claimed_block_request(chain, - web3, - RequestData, - get_execute_data, - get_claim_data): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - first_claim_block = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - - # sanity - assert first_claim_block > web3.eth.blockNumber - - chain.wait.for_block(first_claim_block) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - 'from': web3.eth.accounts[1], - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.accounts[1] - - assert get_claim_data(claim_txn_hash) - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_txn_hash = txn_request.transact({ - 'from': web3.eth.accounts[1], - 'gas': 3000000, - }).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - assert request_data.meta.wasCalled is True - - assert get_execute_data(execute_txn_hash) - - -def test_executing_claimed_call_after_block_reserved_window(chain, - web3, - RequestData, - get_claim_data, - get_execute_data): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - first_claim_block = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - - # sanity - assert first_claim_block > web3.eth.blockNumber - - chain.wait.for_block(first_claim_block) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - 'from': web3.eth.accounts[1], - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.accounts[1] - - assert get_claim_data(claim_txn_hash) - - chain.wait.for_block(request_data.schedule.windowStart + request_data.schedule.reservedWindowSize) - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - assert request_data.meta.wasCalled is True - - assert get_execute_data(execute_txn_hash) - - -def test_claim_block_determines_payment_amount(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - claim_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize + request_data.schedule.claimWindowSize * 2 // 3 - - expected_payment_modifier = 100 * 2 // 3 - - # sanity - assert request_data.claimData.paymentModifier == 0 - assert claim_at > web3.eth.blockNumber - - chain.wait.for_block(claim_at) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.paymentModifier == expected_payment_modifier diff --git a/populus-tests/block-scheduling/test_block_execution_window_enforcement.py b/populus-tests/block-scheduling/test_block_execution_window_enforcement.py deleted file mode 100644 index a844b5caf..000000000 --- a/populus-tests/block-scheduling/test_block_execution_window_enforcement.py +++ /dev/null @@ -1,123 +0,0 @@ -import pytest - - -def test_execution_rejected_if_before_execution_window_for_blocks(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - assert web3.eth.blockNumber < request_data.schedule.windowStart - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.BeforeCallWindow in reasons - - -def test_execution_rejected_if_after_execution_window_for_blocks(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - end_execution_window = request_data.schedule.windowStart + request_data.schedule.windowSize - chain.wait.for_block(end_execution_window + 1) - - assert web3.eth.blockNumber > end_execution_window - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.AfterCallWindow in reasons - - -def test_execution_allowed_at_start_execution_window_for_blocks(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - start_execution_window = request_data.schedule.windowStart - chain.wait.for_block(start_execution_window) - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is True - assert request_data.meta.wasCalled is True - - -def test_execution_allowed_at_end_execution_window_for_blocks(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - end_execution_window = request_data.schedule.windowStart + request_data.schedule.windowSize - chain.wait.for_block(end_execution_window) - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is True - assert request_data.meta.wasCalled is True diff --git a/populus-tests/block-scheduling/test_block_reserved_window_check.py b/populus-tests/block-scheduling/test_block_reserved_window_check.py deleted file mode 100644 index b7b859cb3..000000000 --- a/populus-tests/block-scheduling/test_block_reserved_window_check.py +++ /dev/null @@ -1,46 +0,0 @@ -import pytest - - -def test_execution_rejected_if_claimed_by_other_for_blocks(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - windowStart=web3.eth.blockNumber + 255 + 10 + 5, - toAddress=txn_recorder.address, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - claim_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - 10 - chain.wait.for_block(claim_at) - - txn_request.transact({ - 'from': web3.eth.accounts[1], - 'value': 2 * request_data.paymentData.payment, - }).claim() - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.accounts[1] - - chain.wait.for_block(request_data.schedule.windowStart) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.ReservedForClaimer in reasons diff --git a/populus-tests/block-scheduling/test_block_scheduler.py b/populus-tests/block-scheduling/test_block_scheduler.py deleted file mode 100644 index 189e2a180..000000000 --- a/populus-tests/block-scheduling/test_block_scheduler.py +++ /dev/null @@ -1,123 +0,0 @@ -import pytest - - -@pytest.fixture() -def scheduler(chain, web3, request_factory): - block_scheduler = chain.get_contract('BlockScheduler', deploy_args=[ - request_factory.address, - ]) - chain_code = web3.eth.getCode(block_scheduler.address) - assert len(chain_code) > 10 - - assert request_factory.address == block_scheduler.call().factoryAddress() - - return block_scheduler - - -def test_block_scheduling_with_full_args(chain, - web3, - denoms, - txn_recorder, - scheduler, - request_factory, - request_tracker, - RequestData, - get_txn_request): - window_start = web3.eth.blockNumber + 20 - schedule_txn_hash = scheduler.transact({ - 'value': 10 * denoms.ether, - }).scheduleTransaction( - txn_recorder.address, - 'this-is-the-call-data', - [ - 1212121, # callGas - 123454321, # callValue - 98765, # donation - 80008, # payment - 123, # requiredStackDepth - 54321, # windowSize - window_start, # windowStart - ], - ) - schedule_txn_receipt = web3.eth.getTransactionReceipt(schedule_txn_hash) - - assert schedule_txn_receipt['gasUsed'] < 1300000 - - txn_request = get_txn_request(schedule_txn_hash) - request_data = RequestData.from_contract(txn_request) - - assert request_data.txnData.toAddress == txn_recorder.address - assert request_data.txnData.callData == 'this-is-the-call-data' - assert request_data.schedule.windowSize == 54321 - assert request_data.txnData.callGas == 1212121 - assert request_data.paymentData.donation == 98765 - assert request_data.paymentData.payment == 80008 - assert request_data.txnData.requiredStackDepth == 123 - assert request_data.schedule.windowStart == window_start - - -def test_block_scheduling_with_simplified_args(chain, - web3, - denoms, - txn_recorder, - scheduler, - RequestData, - get_txn_request): - window_start = web3.eth.blockNumber + 20 - schedule_txn_hash = scheduler.transact({ - 'value': 10 * denoms.ether, - }).scheduleTransaction( - txn_recorder.address, - 'this-is-the-call-data', - [ - 1212121, # callGas - 123454321, # callValue - 255, # windowSize - window_start, # windowStart - ], - ) - web3.eth.getTransactionReceipt(schedule_txn_hash) - - txn_request = get_txn_request(schedule_txn_hash) - request_data = RequestData.from_contract(txn_request) - - assert request_data.txnData.toAddress == txn_recorder.address - assert request_data.txnData.callData == 'this-is-the-call-data' - assert request_data.schedule.windowSize == 255 - assert request_data.txnData.callGas == 1212121 - assert request_data.schedule.windowStart == window_start - - -def test_invalid_schedule_returns_ether(chain, - web3, - denoms, - txn_recorder, - scheduler, - RequestData, - get_txn_request): - latest_block = web3.eth.getBlock('latest') - window_start = web3.eth.blockNumber + 20 - - before_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - schedule_txn_hash = scheduler.transact({ - 'value': 10 * denoms.ether, - 'from': web3.eth.accounts[1], - }).scheduleTransaction( - txn_recorder.address, - 'this-is-the-call-data', - [ - latest_block['gasLimit'], # callGas - too high a value. - 123454321, # callValue - 0, # windowSize - window_start, # windowStart - ], - ) - schedule_txn_receipt = web3.eth.getTransactionReceipt(schedule_txn_hash) - - after_balance = web3.eth.getBalance(web3.eth.accounts[1]) - assert before_balance - after_balance <= denoms.ether - assert before_balance - after_balance == schedule_txn_receipt['gasUsed'] * web3.eth.gasPrice - - with pytest.raises(AssertionError): - get_txn_request(schedule_txn_hash) diff --git a/populus-tests/client/test_block_bisection_utility.py b/populus-tests/client/test_block_bisection_utility.py deleted file mode 100644 index 4bf7f2305..000000000 --- a/populus-tests/client/test_block_bisection_utility.py +++ /dev/null @@ -1,98 +0,0 @@ -import bisect - -from alarm_client.utils import ( - find_block_left_of_timestamp, - find_block_right_of_timestamp, -) - - -def test_finding_block_left_of_timestamp(chain, web3, set_timestamp): - chain.wait.for_block(1) - base_block = web3.eth.getBlock('latest') - - base_timestamp = base_block['timestamp'] - - timestamps = [ - base_timestamp, - base_timestamp + 10, - base_timestamp + 10 + 5, - base_timestamp + 10 + 5 + 20, - base_timestamp + 10 + 5 + 20 + 10, - base_timestamp + 10 + 5 + 20 + 10 + 10, - ] - - for timestamp in timestamps[1:]: - set_timestamp(timestamp) - - blocks = [ - web3.eth.getBlock(i) - for i in range(base_block['number'], base_block['number'] + 6) - ] - assert len(blocks) == len(timestamps) - for block, timestamp in zip(blocks, timestamps): - assert block['timestamp'] == timestamp - - earliest_block = web3.eth.getBlock(1) - latest_block = web3.eth.getBlock('latest') - - expected = [ - (i, base_block['number'] + bisect.bisect_right(timestamps, i) - 1) - for i in range(base_timestamp, timestamps[-1] + 1) - ] - - for timestamp, expected_block_number in expected: - if timestamp == earliest_block['timestamp']: - expected_block_number = 'earliest' - if timestamp == latest_block['timestamp']: - expected_block_number = 'latest' - actual_block_number = find_block_left_of_timestamp(web3, timestamp) - assert actual_block_number == expected_block_number - block = web3.eth.getBlock(actual_block_number) - assert block['timestamp'] <= timestamp - - -def test_finding_block_right_of_timestamp(chain, web3, set_timestamp): - chain.wait.for_block(1) - base_block = web3.eth.getBlock('latest') - - base_timestamp = base_block['timestamp'] - - timestamps = [ - base_timestamp, - base_timestamp + 10, - base_timestamp + 10 + 5, - base_timestamp + 10 + 5 + 20, - base_timestamp + 10 + 5 + 20 + 10, - base_timestamp + 10 + 5 + 20 + 10 + 10, - ] - - for timestamp in timestamps[1:]: - set_timestamp(timestamp) - - blocks = [ - web3.eth.getBlock(i) - for i in range(base_block['number'], base_block['number'] + 6) - ] - assert len(blocks) == len(timestamps) - for block, timestamp in zip(blocks, timestamps): - assert block['timestamp'] == timestamp - - earliest_block = web3.eth.getBlock(1) - latest_block = web3.eth.getBlock('latest') - - expected = [ - (i, base_block['number'] + bisect.bisect_left(timestamps, i)) - for i in range(base_timestamp, timestamps[-1] + 1) - ] - - for timestamp, expected_block_number in expected: - if timestamp == earliest_block['timestamp']: - expected_block_number = 'earliest' - if timestamp == latest_block['timestamp']: - expected_block_number = 'latest' - actual_block_number = find_block_right_of_timestamp(web3, timestamp) - assert actual_block_number == expected_block_number - block = web3.eth.getBlock( - 1 if actual_block_number == 'earliest' else actual_block_number - ) - assert block['timestamp'] >= timestamp diff --git a/populus-tests/client/test_request_creation.py b/populus-tests/client/test_request_creation.py deleted file mode 100644 index 8b7040227..000000000 --- a/populus-tests/client/test_request_creation.py +++ /dev/null @@ -1,57 +0,0 @@ -import pytest - -from click.testing import CliRunner - - -from alarm_client.cli import main - - -@pytest.fixture(autouse=True) -def deployed_contract_addresses(monkeypatch, - web3, - request_tracker, - request_factory, - payment_lib, - request_lib): - monkeypatch.setenv('TRACKER_ADDRESS', request_tracker.address) - monkeypatch.setenv('FACTORY_ADDRESS', request_factory.address) - monkeypatch.setenv('REQUEST_LIB_ADDRESS', request_lib.address) - monkeypatch.setenv('PAYMENT_LIB_ADDRESS', payment_lib.address) - monkeypatch.setenv('PROVIDER', 'rpc') - monkeypatch.setenv('RPC_HOST', web3.currentProvider.host) - monkeypatch.setenv('RPC_PORT', web3.currentProvider.port) - - -def test_creating_a_request(chain, - web3, - txn_recorder, - request_factory, - TransactionRequest, - RequestData): - runner = CliRunner() - - window_start = web3.eth.blockNumber + 50 - - result = runner.invoke(main, [ - 'request:create', - '--to-address', txn_recorder.address, - '--window-start', str(window_start), - '--call-data', 'test-call-data', - '--call-gas', '300000', - '--call-value', '12345', - '--no-confirm', - ]) - print(result) - - created_filter = request_factory.pastEvents('RequestCreated') - created_logs = created_filter.get() - - assert len(created_logs) == 1 - - txn_request = TransactionRequest(address=created_logs[0]['args']['request']) - - assert txn_request.callData == 'test-call-data' - assert txn_request.windowStart == window_start - assert txn_request.callGas == 300000 - assert txn_request.callValue == 12345 - assert txn_request.toAddress == txn_recorder.address diff --git a/populus-tests/conftest.py b/populus-tests/conftest.py deleted file mode 100644 index 060246393..000000000 --- a/populus-tests/conftest.py +++ /dev/null @@ -1,574 +0,0 @@ -import os -import functools -import itertools - -import pytest - -import rlp -from ethereum import blocks - -from web3.utils.encoding import ( - decode_hex, -) - -from alarm_client.contracts.transaction_request import TransactionRequestFactory - -from testrpc import testrpc - - -NULL_ADDRESS = '0x0000000000000000000000000000000000000000' - - -@pytest.fixture() -def request_tracker(unmigrated_chain, web3): - chain = unmigrated_chain - tracker = chain.get_contract('RequestTracker') - return tracker - - -@pytest.fixture() -def request_factory(chain, web3, request_tracker): - factory = chain.get_contract('RequestFactory', deploy_args=[request_tracker.address]) - - chain_code = web3.eth.getCode(factory.address) - assert len(chain_code) > 10 - - return factory - - -@pytest.fixture() -def request_lib(chain): - return chain.get_contract('RequestLib') - - -@pytest.fixture() -def RequestLib(request_lib): - return type(request_lib) - - -@pytest.fixture() -def execution_lib(chain): - return chain.get_contract('ExecutionLib') - - -@pytest.fixture() -def ExecutionLib(execution_lib): - return type(execution_lib) - - -@pytest.fixture() -def payment_lib(chain): - return chain.get_contract('PaymentLib') - - -@pytest.fixture() -def PaymentLib(payment_lib): - return type(payment_lib) - - -@pytest.fixture() -def TransactionRequest(chain): - # force lazy deployment of the dependencies for the TransactionRequest - # contract. - chain.get_contract('RequestLib') - BaseTransactionRequest = chain.get_contract_factory('TransactionRequest') - return type( - 'TransactionRequest', - (BaseTransactionRequest, TransactionRequestFactory), - {}, - ) - - -@pytest.fixture() -def RequestFactory(chain, request_factory): - return type(request_factory) - - -@pytest.fixture() -def denoms(): - from web3.utils.currency import units - int_units = { - key: int(value) - for key, value in units.items() - } - return type('denoms', (object,), int_units) - - -MINUTE = 60 - - -@pytest.fixture() -def RequestData(chain, - web3, - request_factory, - get_txn_request, - denoms, - txn_recorder, - TransactionRequest): - class _RequestData(object): - _contract = None - - def __init__(self, - # claim - claimedBy=NULL_ADDRESS, - claimDeposit=0, - paymentModifier=0, - # meta - createdBy=web3.eth.coinbase, - owner=web3.eth.coinbase, - isCancelled=False, - wasCalled=False, - wasSuccessful=False, - # payment - anchorGasPrice=web3.eth.gasPrice, - donation=12345, - donationBenefactor='0xd3cda913deb6f67967b99d67acdfa1712c293601', - donationOwed=0, - payment=54321, - paymentBenefactor=NULL_ADDRESS, - paymentOwed=0, - # txnData - callData="", - toAddress=txn_recorder.address, - callGas=1000000, - callValue=0, - requiredStackDepth=10, - # schedule - claimWindowSize=None, - freezePeriod=None, - windowSize=None, - windowStart=None, - reservedWindowSize=None, - temporalUnit=1): - - if freezePeriod is None: - if temporalUnit == 2: - freezePeriod = 3 * MINUTE - else: - freezePeriod = 10 - - if windowSize is None: - if temporalUnit == 2: - windowSize = 60 * MINUTE - else: - windowSize = 255 - - if windowStart is None: - if temporalUnit == 2: - windowStart = web3.eth.getBlock('latest')['timestamp'] + freezePeriod - else: - windowStart = web3.eth.blockNumber + freezePeriod - - if reservedWindowSize is None: - if temporalUnit == 2: - reservedWindowSize = 4 * MINUTE - else: - reservedWindowSize = 16 - - if claimWindowSize is None: - if temporalUnit == 2: - claimWindowSize = 60 * MINUTE - else: - claimWindowSize = 255 - - self.claimData = type('claimData', (object,), { - 'claimedBy': claimedBy, - 'claimDeposit': claimDeposit, - 'paymentModifier': paymentModifier, - }) - self.meta = type('meta', (object,), { - 'createdBy': createdBy, - 'owner': owner, - 'isCancelled': isCancelled, - 'wasCalled': wasCalled, - 'wasSuccessful': wasSuccessful, - }) - self.paymentData = type('paymentData', (object,), { - 'anchorGasPrice': anchorGasPrice, - 'donation': donation, - 'donationBenefactor': donationBenefactor, - 'donationOwed': donationOwed, - 'payment': payment, - 'paymentBenefactor': paymentBenefactor, - 'paymentOwed': paymentOwed, - }) - self.txnData = type('txnData', (object,), { - 'callData': callData, - 'toAddress': toAddress, - 'callGas': callGas, - 'callValue': callValue, - 'requiredStackDepth': requiredStackDepth, - }) - self.schedule = type('schedule', (object,), { - 'claimWindowSize': claimWindowSize, - 'freezePeriod': freezePeriod, - 'reservedWindowSize': reservedWindowSize, - 'temporalUnit': temporalUnit, - 'windowStart': windowStart, - 'windowSize': windowSize, - }) - - def to_factory_kwargs(self): - return { - 'addressArgs': [ - self.meta.owner, - self.paymentData.donationBenefactor, - self.txnData.toAddress, - ], - 'uintArgs': [ - self.paymentData.donation, - self.paymentData.payment, - self.schedule.claimWindowSize, - self.schedule.freezePeriod, - self.schedule.reservedWindowSize, - self.schedule.temporalUnit, - self.schedule.windowSize, - self.schedule.windowStart, - self.txnData.callGas, - self.txnData.callValue, - self.txnData.requiredStackDepth, - ], - 'callData': self.txnData.callData, - } - - def deploy_via_factory(self, deploy_txn=None): - if deploy_txn is None: - deploy_txn = {'value': 10 * denoms.ether} - create_txn_hash = request_factory.transact( - deploy_txn, - ).createRequest( - **self.to_factory_kwargs() - ) - txn_request = get_txn_request(create_txn_hash) - return txn_request - - def to_init_kwargs(self): - return { - 'addressArgs': [ - self.meta.createdBy, - self.meta.owner, - self.paymentData.donationBenefactor, - self.txnData.toAddress, - ], - 'uintArgs': [ - self.paymentData.donation, - self.paymentData.payment, - self.schedule.claimWindowSize, - self.schedule.freezePeriod, - self.schedule.reservedWindowSize, - self.schedule.temporalUnit, - self.schedule.windowSize, - self.schedule.windowStart, - self.txnData.callGas, - self.txnData.callValue, - self.txnData.requiredStackDepth, - ], - 'callData': self.txnData.callData, - } - - def direct_deploy(self, deploy_txn=None): - if deploy_txn is None: - deploy_txn = {'value': 10 * denoms.ether} - deploy_txn_hash = TransactionRequest.deploy( - transaction=deploy_txn, - kwargs=self.to_init_kwargs(), - ) - txn_request_address = chain.wait.for_contract_address(deploy_txn_hash) - return TransactionRequest(address=txn_request_address) - - def refresh(self): - if not self._contract: - raise ValueError("No contract set") - self.__dict__.update(self.from_contract(self._contract).__dict__) - - @classmethod - def from_contract(cls, txn_request): - address_args, bool_args, uint_args, uint8_args = txn_request.call().requestData() - call_data = txn_request.call().callData() - instance = cls.from_deserialize( - address_args, bool_args, uint_args, uint8_args, call_data, - ) - instance._contract = txn_request - return instance - - @classmethod - def from_deserialize(cls, address_args, bool_args, uint_args, uint8_args, call_data): - init_kwargs = { - 'claimedBy': address_args[0], - 'createdBy': address_args[1], - 'owner': address_args[2], - 'donationBenefactor': address_args[3], - 'paymentBenefactor': address_args[4], - 'toAddress': address_args[5], - 'wasCalled': bool_args[1], - 'wasSuccessful': bool_args[2], - 'isCancelled': bool_args[0], - 'paymentModifier': uint8_args[0], - 'claimDeposit': uint_args[0], - 'anchorGasPrice': uint_args[1], - 'donation': uint_args[2], - 'donationOwed': uint_args[3], - 'payment': uint_args[4], - 'paymentOwed': uint_args[5], - 'claimWindowSize': uint_args[6], - 'freezePeriod': uint_args[7], - 'reservedWindowSize': uint_args[8], - 'temporalUnit': uint_args[9], - 'windowSize': uint_args[10], - 'windowStart': uint_args[11], - 'callGas': uint_args[12], - 'callValue': uint_args[13], - 'requiredStackDepth': uint_args[14], - 'callData': call_data, - } - return cls(**init_kwargs) - return _RequestData - - -@pytest.fixture() -def ValidationErrors(): - return ( - 'InsufficientEndowment', - 'ReservedWindowBiggerThanExecutionWindow', - 'InvalidTemporalUnit', - 'ExecutionWindowTooSoon', - 'InvalidRequiredStackDepth', - 'CallGasTooHigh', - 'EmptyToAddress', - ) - - -@pytest.fixture() -def extract_event_logs(chain, web3, get_all_event_data): - def _extract_event_logs(event_name, contract, txn_hash, return_single=True): - txn_receipt = chain.wait.for_receipt(txn_hash) - filter = contract.pastEvents(event_name, { - 'fromBlock': txn_receipt['blockNumber'], - 'toBlock': txn_receipt['blockNumber'], - }) - log_entries = filter.get() - - if len(log_entries) == 0: - all_event_logs = get_all_event_data(txn_receipt['logs']) - if all_event_logs: - raise AssertionError( - "Something went wrong. The following events were found in" - "the logs for the given transaction hash:\n" - "{0}".format('\n'.join([ - event_log['event'] for event_log in all_event_logs - ])) - ) - raise AssertionError( - "Something went wrong. No '{0}' log entries found".format(event_name) - ) - if return_single: - event_data = log_entries[0] - return event_data - else: - return log_entries - return _extract_event_logs - - -@pytest.fixture() -def get_txn_request(chain, - web3, - extract_event_logs, - RequestFactory, - TransactionRequest, - ValidationErrors): - def _get_txn_request(txn_hash): - try: - request_created_data = extract_event_logs('RequestCreated', RequestFactory, txn_hash) - except AssertionError: - validation_error_data = extract_event_logs('ValidationError', RequestFactory, txn_hash, return_single=False) - if validation_error_data: - errors = [ - ValidationErrors[entry['args']['error']] - for entry in validation_error_data - ] - raise AssertionError("ValidationError: {0}".format(', '.join(errors))) - raise - - request_address = request_created_data['args']['request'] - - txn_request = TransactionRequest(address=request_address) - return txn_request - return _get_txn_request - - -@pytest.fixture -def ABORT_REASONS_ENUM_KEYS(): - return ( - 'WasCancelled', - 'AlreadyCalled', - 'BeforeCallWindow', - 'AfterCallWindow', - 'ReservedForClaimer', - 'StackTooDeep', - 'InsufficientGas', - ) - - -@pytest.fixture() -def AbortReasons(ABORT_REASONS_ENUM_KEYS): - return type('AbortReasons', (object,), { - name: idx for idx, name in enumerate(ABORT_REASONS_ENUM_KEYS) - }) - - -@pytest.fixture() -def get_abort_data(chain, web3, RequestLib, extract_event_logs): - def _get_abort_data(txn_hash, return_single=False): - return extract_event_logs('Aborted', RequestLib, txn_hash, return_single=return_single) - return _get_abort_data - - -@pytest.fixture() -def get_execute_data(chain, - web3, - RequestLib, - extract_event_logs, - get_abort_data, - ABORT_REASONS_ENUM_KEYS): - def _get_execute_data(txn_hash): - try: - return extract_event_logs('Executed', RequestLib, txn_hash) - except AssertionError: - abort_data = get_abort_data(txn_hash, return_single=False) - if abort_data: - errors = [ - ABORT_REASONS_ENUM_KEYS[entry['args']['reason']] - for entry in abort_data - ] - raise AssertionError("Aborted: {0}".format(', '.join(errors))) - raise - return _get_execute_data - - -@pytest.fixture() -def get_claim_data(chain, web3, RequestLib, extract_event_logs): - return functools.partial(extract_event_logs, 'Claimed', RequestLib) - - -@pytest.fixture() -def get_cancel_data(chain, web3, RequestLib, extract_event_logs): - return functools.partial(extract_event_logs, 'Cancelled', RequestLib) - - -@pytest.fixture() -def get_all_event_data(topics_to_abi): - from web3.utils.events import ( - get_event_data, - ) - - def _get_all_event_data(log_entries): - all_event_data = [ - get_event_data(topics_to_abi[log_entry['topics'][0]], log_entry) - for log_entry in log_entries - if log_entry['topics'] and log_entry['topics'][0] in topics_to_abi - ] - return all_event_data - return _get_all_event_data - - -@pytest.fixture() -def topics_to_abi(project): - from web3.utils.abi import ( - filter_by_type, - event_abi_to_log_topic, - ) - all_events_abi = filter_by_type('event', itertools.chain.from_iterable( - contract['abi'] for contract in project.compiled_contracts.values() - )) - _topic_to_abi = { - event_abi_to_log_topic(abi): abi - for abi in all_events_abi - } - return _topic_to_abi - - -@pytest.fixture() -def test_contract_factories(web3): - from solc import compile_files - from populus.utils.filesystem import recursive_find_files - from populus.utils.contracts import ( - package_contracts, - construct_contract_factories, - ) - - base_tests_dir = os.path.dirname(__file__) - - solidity_source_files = recursive_find_files(base_tests_dir, '*.sol') - compiled_contracts = compile_files(solidity_source_files) - test_contract_factories = construct_contract_factories(web3, compiled_contracts) - return package_contracts(test_contract_factories) - - -@pytest.fixture() -def ErrorGenerator(test_contract_factories): - return test_contract_factories.ErrorGenerator - - -@pytest.fixture() -def error_generator(chain, ErrorGenerator): - chain.contract_factories['ErrorGenerator'] = ErrorGenerator - return chain.get_contract('ErrorGenerator') - - -@pytest.fixture() -def TransactionRecorder(test_contract_factories): - return test_contract_factories.TransactionRecorder - - -@pytest.fixture() -def txn_recorder(chain, TransactionRecorder): - chain.contract_factories['TransactionRecorder'] = TransactionRecorder - return chain.get_contract('TransactionRecorder') - - -@pytest.fixture() -def Proxy(test_contract_factories): - return test_contract_factories.Proxy - - -@pytest.fixture() -def proxy(chain, Proxy): - chain.contract_factories['Proxy'] = Proxy - return chain.get_contract('Proxy') - - -@pytest.fixture() -def DiggerProxy(test_contract_factories): - return test_contract_factories.DiggerProxy - - -@pytest.fixture() -def digger_proxy(chain, DiggerProxy): - chain.contract_factories['DiggerProxy'] = DiggerProxy - return chain.get_contract('DiggerProxy') - - -@pytest.fixture() -def evm(web3): - tester_client = testrpc.tester_client - assert web3.eth.blockNumber == len(tester_client.evm.blocks) - 1 - return tester_client.evm - - -@pytest.fixture() -def set_timestamp(web3, evm): - def _set_timestamp(timestamp): - evm.block.finalize() - evm.block.commit_state() - evm.db.put(evm.block.hash, rlp.encode(evm.block)) - - block = blocks.Block.init_from_parent( - evm.block, - decode_hex(web3.eth.coinbase), - timestamp=timestamp, - ) - - evm.block = block - evm.blocks.append(evm.block) - return timestamp - return _set_timestamp diff --git a/populus-tests/request-factory/test_request_factory.py b/populus-tests/request-factory/test_request_factory.py deleted file mode 100644 index 281035722..000000000 --- a/populus-tests/request-factory/test_request_factory.py +++ /dev/null @@ -1,286 +0,0 @@ -def test_request_factory_creates_request_with_provided_properties(chain, - web3, - denoms, - txn_recorder, - request_factory, - RequestData): - request_lib = chain.get_contract('RequestLib') - window_start = web3.eth.blockNumber + 20 - - expected_request_data = RequestData( - claimWindowSize=255, - donation=12345, - payment=54321, - freezePeriod=10, - windowStart=window_start, - windowSize=511, - reservedWindowSize=16, - temporalUnit=1, - callValue=123456789, - callGas=1000000, - requiredStackDepth=0 - ) - is_valid = request_lib.call().validate( - endowment=10 * denoms.ether, - **expected_request_data.to_init_kwargs() - ) - assert all(is_valid) - - txn_request = expected_request_data.deploy_via_factory() - - actual_request_data = RequestData.from_contract(txn_request) - - assert actual_request_data.meta.owner == web3.eth.coinbase - assert actual_request_data.meta.createdBy == web3.eth.coinbase - assert actual_request_data.meta.isCancelled is False - assert actual_request_data.meta.wasCalled is False - assert actual_request_data.meta.wasSuccessful is False - - assert actual_request_data.claimData.claimedBy == '0x0000000000000000000000000000000000000000' - assert actual_request_data.claimData.claimDeposit == 0 - assert actual_request_data.claimData.paymentModifier == 0 - - assert actual_request_data.paymentData.donation == 12345 - assert actual_request_data.paymentData.donationBenefactor == '0xd3cda913deb6f67967b99d67acdfa1712c293601' - assert actual_request_data.paymentData.donationOwed == 0 - assert actual_request_data.paymentData.payment == 54321 - assert actual_request_data.paymentData.paymentBenefactor == '0x0000000000000000000000000000000000000000' - assert actual_request_data.paymentData.paymentOwed == 0 - - assert actual_request_data.schedule.claimWindowSize == 255 - assert actual_request_data.schedule.freezePeriod == 10 - assert actual_request_data.schedule.windowStart == window_start - assert actual_request_data.schedule.windowSize == 511 - assert actual_request_data.schedule.reservedWindowSize == 16 - assert actual_request_data.schedule.temporalUnit == 1 - - assert actual_request_data.txnData.toAddress == txn_recorder.address - assert actual_request_data.txnData.callData == '' - assert actual_request_data.txnData.callValue == 123456789 - assert actual_request_data.txnData.callGas == 1000000 - assert actual_request_data.txnData.requiredStackDepth == 0 - - # sanity - assert request_factory.call().isKnownRequest(web3.eth.coinbase) is False - - # does it track the requests it has created. - assert request_factory.call().isKnownRequest(txn_request.address) is True - - -def test_request_factory_insufficient_endowment_validation_error(chain, - web3, - denoms, - txn_recorder, - RequestData): - request_lib = chain.get_contract('RequestLib') - window_start = web3.eth.blockNumber + 20 - - expected_request_data = RequestData( - claimWindowSize=255, - donation=12345, - payment=54321, - freezePeriod=10, - windowStart=window_start, - windowSize=255, - reservedWindowSize=16, - temporalUnit=1, - callValue=123456789, - callGas=1000000, - requiredStackDepth=0 - ) - is_valid = request_lib.call().validate( - endowment=1, # too small of an endowment. - **expected_request_data.to_init_kwargs() - ) - assert not all(is_valid) - assert is_valid[0] is False - assert all(is_valid[1:]) - - -def test_request_factory_too_large_reserved_window_validation_error(chain, - web3, - denoms, - txn_recorder, - RequestData): - request_lib = chain.get_contract('RequestLib') - window_start = web3.eth.blockNumber + 20 - - expected_request_data = RequestData( - claimWindowSize=255, - donation=12345, - payment=54321, - freezePeriod=10, - windowStart=window_start, - windowSize=255, - reservedWindowSize=255 + 2, # 2 more than the window size. - temporalUnit=1, - callValue=123456789, - callGas=1000000, - requiredStackDepth=0 - ) - is_valid = request_lib.call().validate( - endowment=10 * denoms.ether, - **expected_request_data.to_init_kwargs() - ) - assert not all(is_valid) - assert is_valid[1] is False - assert all(is_valid[:1]) - assert all(is_valid[2:]) - - -def test_request_factory_invalid_temporal_unit_validation_error(chain, - web3, - denoms, - txn_recorder, - RequestData): - request_lib = chain.get_contract('RequestLib') - window_start = web3.eth.blockNumber + 20 - - expected_request_data = RequestData( - claimWindowSize=255, - donation=12345, - payment=54321, - freezePeriod=10, - windowStart=window_start, - windowSize=255, - reservedWindowSize=16, - temporalUnit=3, # Only 1, and 2 are supported. - callValue=123456789, - callGas=1000000, - requiredStackDepth=0 - ) - is_valid = request_lib.call().validate( - endowment=10 * denoms.ether, - **expected_request_data.to_init_kwargs() - ) - assert not all(is_valid) - assert is_valid[2] is False - assert is_valid[3] is False # because it defaults to `seconds` if the temporal unit is too big. - assert all(is_valid[:2]) - assert all(is_valid[4:]) - - -def test_request_factory_too_soon_execution_window_validation_error(chain, - web3, - denoms, - txn_recorder, - RequestData): - request_lib = chain.get_contract('RequestLib') - window_start = web3.eth.blockNumber + 10 - - expected_request_data = RequestData( - claimWindowSize=255, - donation=12345, - payment=54321, - freezePeriod=11, # more than the number of blocks between now and the windowStart. - windowStart=window_start, - windowSize=255, - reservedWindowSize=16, - temporalUnit=1, - callValue=123456789, - callGas=1000000, - requiredStackDepth=0 - ) - is_valid = request_lib.call().validate( - endowment=10 * denoms.ether, - **expected_request_data.to_init_kwargs() - ) - assert not all(is_valid) - assert is_valid[3] is False - assert all(is_valid[:3]) - assert all(is_valid[4:]) - - -def test_request_factory_invalid_required_stack_depth_validation_error(chain, - web3, - denoms, - txn_recorder, - RequestData): - request_lib = chain.get_contract('RequestLib') - window_start = web3.eth.blockNumber + 20 - - expected_request_data = RequestData( - claimWindowSize=255, - donation=12345, - payment=54321, - freezePeriod=10, - windowStart=window_start, - windowSize=255, - reservedWindowSize=16, - temporalUnit=1, - callValue=123456789, - callGas=1000000, - requiredStackDepth=1025, - ) - is_valid = request_lib.call().validate( - endowment=10 * denoms.ether, - **expected_request_data.to_init_kwargs() - ) - assert not all(is_valid) - assert is_valid[4] is False - assert all(is_valid[:4]) - assert all(is_valid[5:]) - - -def test_request_factory_too_high_call_gas_validation_error(chain, - web3, - denoms, - txn_recorder, - RequestData): - last_block = web3.eth.getBlock('latest') - - request_lib = chain.get_contract('RequestLib') - window_start = web3.eth.blockNumber + 20 - - expected_request_data = RequestData( - claimWindowSize=255, - donation=12345, - payment=54321, - freezePeriod=10, - windowStart=window_start, - windowSize=255, - reservedWindowSize=16, - temporalUnit=1, - callValue=123456789, - callGas=last_block['gasLimit'], # cannot be at gas limit. - requiredStackDepth=0, - ) - is_valid = request_lib.call().validate( - endowment=10 * denoms.ether, - **expected_request_data.to_init_kwargs() - ) - assert not all(is_valid) - assert is_valid[5] is False - assert all(is_valid[:5]) - assert all(is_valid[6:]) - - -def test_request_factory_to_address_as_null_validation_error(chain, - web3, - denoms, - txn_recorder, - RequestData): - request_lib = chain.get_contract('RequestLib') - window_start = web3.eth.blockNumber + 20 - - expected_request_data = RequestData( - toAddress='0x0000000000000000000000000000000000000000', # cannot send to 0x0 - claimWindowSize=255, - donation=12345, - payment=54321, - freezePeriod=10, - windowStart=window_start, - windowSize=255, - reservedWindowSize=16, - temporalUnit=1, - callValue=123456789, - callGas=1000000, - requiredStackDepth=0, - ) - is_valid = request_lib.call().validate( - endowment=10 * denoms.ether, - **expected_request_data.to_init_kwargs() - ) - assert not all(is_valid) - assert is_valid[6] is False - assert all(is_valid[:6]) diff --git a/populus-tests/timestamp-scheduling/test_timestamp_claiming.py b/populus-tests/timestamp-scheduling/test_timestamp_claiming.py deleted file mode 100644 index 65f3d2764..000000000 --- a/populus-tests/timestamp-scheduling/test_timestamp_claiming.py +++ /dev/null @@ -1,243 +0,0 @@ -import pytest - - -DAY = 60 * 60 * 24 - - -def test_cannot_claim_before_first_claim_timestamp(chain, - web3, - RequestData, - set_timestamp, - get_claim_data): - window_start = web3.eth.getBlock('latest')['timestamp'] + DAY - txn_request = RequestData( - temporalUnit=2, - windowStart=window_start, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - first_claim_timestamp = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - - # sanity - assert first_claim_timestamp > web3.eth.getBlock('latest')['timestamp'] - - set_timestamp(first_claim_timestamp - 10) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - with pytest.raises(AssertionError): - get_claim_data(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == '0x0000000000000000000000000000000000000000' - - -def test_can_claim_at_first_claim_timestamp(chain, - web3, - RequestData, - set_timestamp, - get_claim_data): - window_start = web3.eth.getBlock('latest')['timestamp'] + DAY - txn_request = RequestData( - temporalUnit=2, - windowStart=window_start, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - first_claim_timestamp = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - - # sanity - assert first_claim_timestamp > web3.eth.getBlock('latest')['timestamp'] - - set_timestamp(first_claim_timestamp) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - claim_data = get_claim_data(claim_txn_hash) - assert claim_data - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.coinbase - - -def test_can_claim_at_last_claim_timestamp(chain, - web3, - set_timestamp, - RequestData): - window_start = web3.eth.getBlock('latest')['timestamp'] + DAY - txn_request = RequestData( - temporalUnit=2, - windowStart=window_start, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - last_claim_timestamp = request_data.schedule.windowStart - request_data.schedule.freezePeriod - - # sanity - assert last_claim_timestamp > web3.eth.getBlock('latest')['timestamp'] - - set_timestamp(last_claim_timestamp - 17) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.coinbase - - -def test_cannot_claim_after_last_claim_timestamp(chain, - web3, - RequestData, - set_timestamp, - get_claim_data): - window_start = web3.eth.getBlock('latest')['timestamp'] + DAY - txn_request = RequestData( - temporalUnit=2, - windowStart=window_start, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - last_claim_timestamp = request_data.schedule.windowStart - request_data.schedule.freezePeriod - - # sanity - assert last_claim_timestamp > web3.eth.getBlock('latest')['timestamp'] - - set_timestamp(last_claim_timestamp + 1) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - with pytest.raises(AssertionError): - get_claim_data(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == '0x0000000000000000000000000000000000000000' - - -def test_executing_own_claimed_timestamp_based_request(chain, - web3, - RequestData, - get_execute_data, - set_timestamp, - get_claim_data): - window_start = web3.eth.getBlock('latest')['timestamp'] + DAY - txn_request = RequestData( - temporalUnit=2, - windowStart=window_start, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - first_claim_timestamp = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - - # sanity - assert first_claim_timestamp > web3.eth.getBlock('latest')['timestamp'] - - set_timestamp(first_claim_timestamp) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - 'from': web3.eth.accounts[1], - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.accounts[1] - - assert get_claim_data(claim_txn_hash) - - set_timestamp(request_data.schedule.windowStart) - - execute_txn_hash = txn_request.transact({ - 'from': web3.eth.accounts[1], - 'gas': 3000000, - }).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - assert request_data.meta.wasCalled is True - - assert get_execute_data(execute_txn_hash) - - -def test_executing_other_claimed_call_after_timestamp_reserved_window(chain, - web3, - RequestData, - set_timestamp, - get_claim_data, - get_execute_data): - window_start = web3.eth.getBlock('latest')['timestamp'] + DAY - txn_request = RequestData( - temporalUnit=2, - windowStart=window_start, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - first_claim_timestamp = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - - # sanity - assert first_claim_timestamp > web3.eth.getBlock('latest')['timestamp'] - - set_timestamp(first_claim_timestamp) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - 'from': web3.eth.accounts[1], - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.accounts[1] - - assert get_claim_data(claim_txn_hash) - - set_timestamp( - request_data.schedule.windowStart + request_data.schedule.reservedWindowSize - ) - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - assert request_data.meta.wasCalled is True - - assert get_execute_data(execute_txn_hash) - - -def test_claim_timestamp_determines_payment_amount(chain, - web3, - set_timestamp, - RequestData): - window_start = web3.eth.getBlock('latest')['timestamp'] + DAY - txn_request = RequestData( - temporalUnit=2, - windowStart=window_start, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - claim_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize + request_data.schedule.claimWindowSize * 2 // 3 - - expected_payment_modifier = 100 * 2 // 3 - - # sanity - assert request_data.claimData.paymentModifier == 0 - assert claim_at > web3.eth.getBlock('latest')['timestamp'] - - set_timestamp(claim_at) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.paymentModifier == expected_payment_modifier diff --git a/populus-tests/timestamp-scheduling/test_timestamp_execution_window_enforcement.py b/populus-tests/timestamp-scheduling/test_timestamp_execution_window_enforcement.py deleted file mode 100644 index 1f45ed1bf..000000000 --- a/populus-tests/timestamp-scheduling/test_timestamp_execution_window_enforcement.py +++ /dev/null @@ -1,130 +0,0 @@ -import pytest - - -def test_execution_rejected_if_before_execution_window_for_timestamps(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - temporalUnit=2, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - assert web3.eth.getBlock('latest')['timestamp'] < request_data.schedule.windowStart - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.BeforeCallWindow in reasons - - -def test_execution_rejected_if_after_execution_window_for_timestamps(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - set_timestamp, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - temporalUnit=2, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - end_execution_window = request_data.schedule.windowStart + request_data.schedule.windowSize - set_timestamp(end_execution_window + 1) - - assert web3.eth.getBlock('latest')['timestamp'] > end_execution_window - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.AfterCallWindow in reasons - - -def test_execution_allowed_at_start_execution_window_for_timestamps(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - set_timestamp, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - temporalUnit=2, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - start_execution_window = request_data.schedule.windowStart - set_timestamp(start_execution_window) - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is True - assert request_data.meta.wasCalled is True - - -def test_execution_allowed_at_end_execution_window_for_timestamps(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - set_timestamp, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - temporalUnit=2, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - end_execution_window = request_data.schedule.windowStart + request_data.schedule.windowSize - set_timestamp(end_execution_window) - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is True - assert request_data.meta.wasCalled is True diff --git a/populus-tests/timestamp-scheduling/test_timestamp_reserved_window_check.py b/populus-tests/timestamp-scheduling/test_timestamp_reserved_window_check.py deleted file mode 100644 index 0cae94b85..000000000 --- a/populus-tests/timestamp-scheduling/test_timestamp_reserved_window_check.py +++ /dev/null @@ -1,49 +0,0 @@ -import pytest - - -def test_execution_rejected_if_claimed_by_other_for_timestamp(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - set_timestamp, - get_abort_data, - AbortReasons): - window_start = web3.eth.getBlock('latest')['timestamp'] + 60 * 60 * 24 - txn_request = RequestData( - windowStart=window_start, - toAddress=txn_recorder.address, - temporalUnit=2, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - claim_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - 60 - set_timestamp(claim_at) - - txn_request.transact({ - 'from': web3.eth.accounts[1], - 'value': 2 * request_data.paymentData.payment, - }).claim() - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.accounts[1] - - set_timestamp(request_data.schedule.windowStart) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.ReservedForClaimer in reasons diff --git a/populus-tests/timestamp-scheduling/test_timestamp_scheduler.py b/populus-tests/timestamp-scheduling/test_timestamp_scheduler.py deleted file mode 100644 index 11ae94645..000000000 --- a/populus-tests/timestamp-scheduling/test_timestamp_scheduler.py +++ /dev/null @@ -1,129 +0,0 @@ -import pytest - - -@pytest.fixture() -def scheduler(chain, web3, request_factory): - timestamp_scheduler = chain.get_contract('TimestampScheduler', deploy_args=[ - request_factory.address, - ]) - chain_code = web3.eth.getCode(timestamp_scheduler.address) - assert len(chain_code) > 10 - - assert request_factory.address == timestamp_scheduler.call().factoryAddress() - - return timestamp_scheduler - - -MINUTE = 60 - - -def test_timestamp_scheduling_with_full_args(chain, - web3, - denoms, - txn_recorder, - scheduler, - request_factory, - request_tracker, - RequestData, - evm, - set_timestamp, - get_txn_request): - print("Now Factory", request_factory.address) - window_start = web3.eth.getBlock('latest')['timestamp'] + 10 * MINUTE - schedule_txn_hash = scheduler.transact({ - 'value': 10 * denoms.ether, - }).scheduleTransaction( - txn_recorder.address, - 'this-is-the-call-data', - [ - 1212121, # callGas - 123454321, # callValue - 98765, # donation - 80008, # payment - 123, # requiredStackDepth - 55 * MINUTE, # windowSize - window_start, # windowStart - ], - ) - schedule_txn_receipt = web3.eth.getTransactionReceipt(schedule_txn_hash) - - assert schedule_txn_receipt['gasUsed'] < 1300000 - - txn_request = get_txn_request(schedule_txn_hash) - request_data = RequestData.from_contract(txn_request) - - assert request_data.txnData.toAddress == txn_recorder.address - assert request_data.txnData.callData == 'this-is-the-call-data' - assert request_data.schedule.windowSize == 55 * MINUTE - assert request_data.txnData.callGas == 1212121 - assert request_data.paymentData.donation == 98765 - assert request_data.paymentData.payment == 80008 - assert request_data.txnData.requiredStackDepth == 123 - assert request_data.schedule.windowStart == window_start - - -def test_timestamp_scheduling_with_simplified_args(chain, - web3, - denoms, - txn_recorder, - scheduler, - RequestData, - get_txn_request): - window_start = web3.eth.getBlock('latest')['timestamp'] + 6 * MINUTE - schedule_txn_hash = scheduler.transact({ - 'value': 10 * denoms.ether, - }).scheduleTransaction( - txn_recorder.address, - 'this-is-the-call-data', - [ - 1212121, # callGas - 123454321, # callValue - 55 * MINUTE, # windowSize - window_start, # windowStart - ], - ) - web3.eth.getTransactionReceipt(schedule_txn_hash) - - txn_request = get_txn_request(schedule_txn_hash) - request_data = RequestData.from_contract(txn_request) - - assert request_data.txnData.toAddress == txn_recorder.address - assert request_data.txnData.callData == 'this-is-the-call-data' - assert request_data.schedule.windowSize == 55 * MINUTE - assert request_data.txnData.callGas == 1212121 - assert request_data.schedule.windowStart == window_start - - -def test_invalid_schedule_returns_ether(chain, - web3, - denoms, - txn_recorder, - scheduler, - RequestData, - get_txn_request): - latest_block = web3.eth.getBlock('latest') - window_start = latest_block['timestamp'] + 6 * MINUTE - - before_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - schedule_txn_hash = scheduler.transact({ - 'value': 10 * denoms.ether, - 'from': web3.eth.accounts[1], - }).scheduleTransaction( - txn_recorder.address, - 'this-is-the-call-data', - [ - latest_block['gasLimit'], # callGas - too high a value. - 123454321, # callValue - 55 * MINUTE, # windowSize - window_start, # windowStart - ], - ) - schedule_txn_receipt = web3.eth.getTransactionReceipt(schedule_txn_hash) - - after_balance = web3.eth.getBalance(web3.eth.accounts[1]) - assert before_balance - after_balance <= denoms.ether - assert before_balance - after_balance == schedule_txn_receipt['gasUsed'] * web3.eth.gasPrice - - with pytest.raises(AssertionError): - get_txn_request(schedule_txn_hash) diff --git a/populus-tests/transaction-request/test_accounting.py b/populus-tests/transaction-request/test_accounting.py deleted file mode 100644 index debbfbce3..000000000 --- a/populus-tests/transaction-request/test_accounting.py +++ /dev/null @@ -1,313 +0,0 @@ -import pytest -from web3.utils.encoding import decode_hex - - -def test_txn_request_payments(chain, - web3, - get_execute_data, - RequestData): - txn_request = RequestData(donation=12345).direct_deploy() - request_data = RequestData.from_contract(txn_request) - assert request_data.paymentData.donation == 12345 - - before_donation_balance = web3.eth.getBalance(request_data.paymentData.donationBenefactor) - before_payment_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_txn_hash = txn_request.transact({ - 'from': web3.eth.accounts[1], - 'gas': 3000000, - }).execute() - execute_txn = web3.eth.getTransaction(execute_txn_hash) - execute_txn_receipt = chain.wait.for_receipt(execute_txn_hash) - - execute_data = get_execute_data(execute_txn_hash) - - after_donation_balance = web3.eth.getBalance(request_data.paymentData.donationBenefactor) - after_payment_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - donation = execute_data['args']['donation'] - assert donation == 12345 - assert after_donation_balance - before_donation_balance == donation - - payment = execute_data['args']['payment'] - - gas_price = execute_txn['gasPrice'] - gas_used = execute_txn_receipt['gasUsed'] - gas_cost = gas_used * gas_price - - expected_payment = gas_cost + request_data.paymentData.payment - - assert payment >= expected_payment - assert payment - expected_payment < 120000 * gas_price - - assert after_payment_balance - before_payment_balance == payment - gas_cost - - -def test_txn_request_payments_when_claimed(chain, web3, get_execute_data, RequestData): - txn_request = RequestData(donation=12345, windowStart=web3.eth.blockNumber + 10 + 255 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - before_payment_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - claim_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - 5 - - assert claim_at > web3.eth.blockNumber - - chain.wait.for_block(claim_at) - - claim_deposit = 2 * request_data.paymentData.payment - assert claim_deposit > 0 - - claim_txn_hash = txn_request.transact({ - 'value': claim_deposit, - 'from': web3.eth.accounts[1], - }).claim() - claim_txn = web3.eth.getTransaction(claim_txn_hash) - claim_txn_receipt = chain.wait.for_receipt(claim_txn_hash) - claim_gas_cost = claim_txn['gasPrice'] * claim_txn_receipt['gasUsed'] - - after_claim_balance = web3.eth.getBalance(web3.eth.accounts[1]) - assert before_payment_balance - after_claim_balance == claim_deposit + claim_gas_cost - - request_data.refresh() - - assert request_data.claimData.claimedBy == web3.eth.accounts[1] - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_txn_hash = txn_request.transact({ - 'from': web3.eth.accounts[1], - 'gas': 3000000, - }).execute() - execute_txn = web3.eth.getTransaction(execute_txn_hash) - execute_txn_receipt = chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - execute_data = get_execute_data(execute_txn_hash) - - after_payment_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - payment = execute_data['args']['payment'] - - gas_price = execute_txn['gasPrice'] - gas_used = execute_txn_receipt['gasUsed'] - gas_cost = gas_used * gas_price - - expected_payment = claim_deposit + gas_cost + request_data.claimData.paymentModifier * request_data.paymentData.payment // 100 - - assert payment >= expected_payment - assert payment - expected_payment < 100000 * gas_price - - assert after_payment_balance - before_payment_balance == payment - claim_deposit - gas_cost - claim_gas_cost - - -def test_accounting_when_everything_throws(chain, - web3, - get_execute_data, - RequestData, - error_generator): - txn_request = RequestData( - createdBy=error_generator.address, - owner=error_generator.address, - donationBenefactor=error_generator.address, - toAddress=error_generator.address, - callData=decode_hex(error_generator._encode_transaction_data('doThrow')), - windowStart=web3.eth.blockNumber + 10 + 255 + 5, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - claim_at = request_data.schedule.windowStart - 10 - 5 - deposit_amount = request_data.paymentData.payment * 2 - - assert claim_at > web3.eth.blockNumber - - chain.wait.for_block(claim_at) - - claim_call_data = decode_hex(txn_request._encode_transaction_data('claim')) - claim_txn_hash = error_generator.transact({ - 'value': deposit_amount, - }).__proxy(txn_request.address, claim_call_data, ) - chain.wait.for_receipt(claim_txn_hash) - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_call_data = decode_hex(txn_request._encode_transaction_data('execute')) - - execute_txn_hash = error_generator.transact({ - 'from': web3.eth.accounts[1], - 'gas': 3000000, - }).__proxy( - to=txn_request.address, - callData=execute_call_data, - ) - execute_txn_receipt = chain.wait.for_receipt(execute_txn_hash) - - chain.wait.for_block(request_data.schedule.windowStart + request_data.schedule.windowSize) - - execute_data = get_execute_data(execute_txn_hash) - request_data.refresh() - - assert request_data.meta.wasCalled is True - assert request_data.meta.wasSuccessful is False - - gas_used = execute_txn_receipt['gasUsed'] - measured_gas_consumption = execute_data['args']['measuredGasConsumption'] - - assert measured_gas_consumption > gas_used - assert measured_gas_consumption - gas_used < 50000 - - payment_owed = request_data.paymentData.paymentOwed - donation_owed = request_data.paymentData.donationOwed - - assert payment_owed > 0 - assert payment_owed == execute_data['args']['payment'] - assert donation_owed > 0 - assert donation_owed == execute_data['args']['donation'] - - # make the contract stop throwing now. - chain.wait.for_receipt(error_generator.transact().toggle()) - assert error_generator.call().shouldThrow() is False - - before_payments_contract_balance = web3.eth.getBalance(txn_request.address) - - before_owner_refund_balance = web3.eth.getBalance(error_generator.address) - - issue_owner_refund_txn_hash = txn_request.transact().sendOwnerEther() - chain.wait.for_receipt(issue_owner_refund_txn_hash) - - after_owner_refund_balance = web3.eth.getBalance(error_generator.address) - owner_refund = after_owner_refund_balance - before_owner_refund_balance - assert owner_refund > 0 - - before_payment_balance = web3.eth.getBalance(error_generator.address) - - issue_payment_txn_hash = txn_request.transact().sendPayment() - chain.wait.for_receipt(issue_payment_txn_hash) - request_data.refresh() - - after_payment_balance = web3.eth.getBalance(error_generator.address) - assert after_payment_balance - before_payment_balance == payment_owed - - before_donation_balance = web3.eth.getBalance(error_generator.address) - - issue_donation_txn_hash = txn_request.transact().sendDonation() - chain.wait.for_receipt(issue_donation_txn_hash) - request_data.refresh() - - after_donation_balance = web3.eth.getBalance(error_generator.address) - assert after_donation_balance - before_donation_balance == donation_owed - - assert owner_refund + payment_owed + donation_owed == before_payments_contract_balance - - -def test_claim_deposit_held_by_contract_on_claim(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - claim_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - 10 - - # sanity - assert claim_at > web3.eth.blockNumber - - chain.wait.for_block(claim_at) - - deposit_amount = 2 * request_data.paymentData.payment - - before_contract_balance = web3.eth.getBalance(txn_request.address) - before_account_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - claim_txn_hash = txn_request.transact({ - 'value': deposit_amount, - 'from': web3.eth.accounts[1], - }).claim() - claim_txn_receipt = chain.wait.for_receipt(claim_txn_hash) - - after_contract_balance = web3.eth.getBalance(txn_request.address) - after_account_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - assert after_contract_balance - before_contract_balance == deposit_amount - assert before_account_balance - after_account_balance == deposit_amount + web3.eth.gasPrice * claim_txn_receipt['gasUsed'] - - request_data.refresh() - assert request_data.claimData.claimedBy == web3.eth.accounts[1] - - -def test_claim_deposit_returned_if_claim_rejected(chain, - web3, - RequestData, - get_claim_data): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - try_claim_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - 3 - - # sanity - assert try_claim_at > web3.eth.blockNumber - - chain.wait.for_block(try_claim_at) - - deposit_amount = 2 * request_data.paymentData.payment - - before_contract_balance = web3.eth.getBalance(txn_request.address) - before_account_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - claim_txn_hash = txn_request.transact({ - 'value': deposit_amount, - 'from': web3.eth.accounts[1], - }).claim() - claim_txn = web3.eth.getTransaction(claim_txn_hash) - claim_txn_receipt = chain.wait.for_receipt(claim_txn_hash) - - after_contract_balance = web3.eth.getBalance(txn_request.address) - after_account_balance = web3.eth.getBalance(web3.eth.accounts[1]) - - assert after_contract_balance == before_contract_balance - assert after_account_balance == before_account_balance - claim_txn['gasPrice'] * claim_txn_receipt['gasUsed'] - - with pytest.raises(AssertionError): - get_claim_data(claim_txn_hash) - - request_data.refresh() - assert request_data.claimData.claimedBy == '0x0000000000000000000000000000000000000000' - - -def test_claim_deposit_returned_even_if_returning_it_throws(chain, - web3, - RequestData, - get_claim_data, - error_generator): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - try_claim_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - 3 - - # sanity - assert try_claim_at > web3.eth.blockNumber - - chain.wait.for_block(try_claim_at) - - deposit_amount = 2 * request_data.paymentData.payment - - before_contract_balance = web3.eth.getBalance(txn_request.address) - before_account_balance = web3.eth.getBalance(error_generator.address) - - assert before_account_balance == 0 - - claim_call_data = decode_hex(txn_request._encode_transaction_data('claim')) - - claim_txn_hash = error_generator.transact({ - 'value': deposit_amount, - }).__proxy(txn_request.address, claim_call_data, ) - chain.wait.for_receipt(claim_txn_hash) - - after_contract_balance = web3.eth.getBalance(txn_request.address) - after_account_balance = web3.eth.getBalance(error_generator.address) - - assert after_contract_balance == before_contract_balance - assert after_account_balance == deposit_amount - - request_data.refresh() - assert request_data.claimData.claimedBy == '0x0000000000000000000000000000000000000000' diff --git a/populus-tests/transaction-request/test_already_executed_check.py b/populus-tests/transaction-request/test_already_executed_check.py deleted file mode 100644 index 375fe0452..000000000 --- a/populus-tests/transaction-request/test_already_executed_check.py +++ /dev/null @@ -1,35 +0,0 @@ -import pytest - - -def test_execution_rejected_if_already_executed(chain, - RequestData, - txn_recorder, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - assert txn_recorder.call().wasCalled() is True - request_data.refresh() - assert request_data.meta.wasCalled is True - - duplicate_execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(duplicate_execute_txn_hash) - - with pytest.raises(AssertionError): - get_execute_data(duplicate_execute_txn_hash) - - abort_data = get_abort_data(duplicate_execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.AlreadyCalled in reasons diff --git a/populus-tests/transaction-request/test_cancelling.py b/populus-tests/transaction-request/test_cancelling.py deleted file mode 100644 index c027631d6..000000000 --- a/populus-tests/transaction-request/test_cancelling.py +++ /dev/null @@ -1,325 +0,0 @@ -def test_cancelling_before_claim_window(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - 3 - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(cancel_txn_hash) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is True - - -def test_non_owner_cannot_cancel_before_claim_window(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - request_data.schedule.claimWindowSize - 3 - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - cancel_txn_hash = txn_request.transact({'from': web3.eth.accounts[1]}).cancel() - chain.wait.for_receipt(cancel_txn_hash) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is False - - -def test_cancelling_during_claim_window_when_unclaimed(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - 20 - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(cancel_txn_hash) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is True - - -def test_not_cancellable_once_claimed(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - 20 - claim_at = cancel_at - 5 - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(claim_at) - - claim_txn_hash = txn_request.transact({ - 'value': 2 * request_data.paymentData.payment, - 'from': web3.eth.accounts[1], - }).claim() - chain.wait.for_receipt(claim_txn_hash) - - claimed_request_data = RequestData.from_contract(txn_request) - assert claimed_request_data.claimData.claimedBy == web3.eth.accounts[1] - - cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(cancel_txn_hash) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is False - - -def test_not_cancellable_during_freeze_window(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(cancel_txn_hash) - - request_data.refresh() - assert request_data.meta.isCancelled is False - - -def test_not_cancellable_during_execution_window(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(cancel_txn_hash) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is False - - -def test_not_cancellable_if_was_called(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - execute_at = request_data.schedule.windowStart - cancel_at_first = request_data.schedule.windowStart + 10 - cancel_at_second = request_data.schedule.windowStart + request_data.schedule.windowSize + 5 - - # sanity - assert execute_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(execute_at) - - execute_txn_hash = txn_request.transact({ - 'gas': 3000000, - }).execute() - chain.wait.for_receipt(execute_txn_hash) - - after_execute_request_data = RequestData.from_contract(txn_request) - assert after_execute_request_data.meta.wasCalled is True - assert after_execute_request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at_first) - - first_cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(first_cancel_txn_hash) - - after_first_cancel_request_data = RequestData.from_contract(txn_request) - assert after_first_cancel_request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at_second) - - second_cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(second_cancel_txn_hash) - - after_second_cancel_request_data = RequestData.from_contract(txn_request) - assert after_second_cancel_request_data.meta.isCancelled is False - - -def test_cancellable_if_call_is_missed(chain, web3, RequestData): - txn_request = RequestData(windowStart=web3.eth.blockNumber + 255 + 10 + 5).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart + request_data.schedule.windowSize + 10 - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(cancel_txn_hash) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is True - - -def test_accounting_for_pre_execution_cancellation(chain, - web3, - denoms, - RequestData, - get_cancel_data): - txn_request = RequestData( - windowStart=web3.eth.blockNumber + 255 + 10 + 5, - owner=web3.eth.accounts[1], - ).direct_deploy({ - 'from': web3.eth.accounts[1], - 'value': 10 * denoms.ether, - }) - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart - request_data.schedule.freezePeriod - 5 - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.accounts[1] - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - before_cancel_balance = web3.eth.getBalance(web3.eth.accounts[1]) - before_contract_balance = web3.eth.getBalance(txn_request.address) - - cancel_txn_hash = txn_request.transact({'from': web3.eth.accounts[1]}).cancel() - cancel_txn_receipt = chain.wait.for_receipt(cancel_txn_hash) - - after_cancel_balance = web3.eth.getBalance(web3.eth.accounts[1]) - after_contract_balance = web3.eth.getBalance(txn_request.address) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is True - - cancel_data = get_cancel_data(cancel_txn_hash) - # since this was cancelled by the owner. - assert cancel_data['args']['rewardPayment'] == 0 - assert cancel_data['args']['measuredGasConsumption'] == 0 - - assert before_contract_balance == 10 * denoms.ether - assert after_contract_balance == 0 - - assert after_cancel_balance - before_cancel_balance == 10 * denoms.ether - cancel_txn_receipt['gasUsed'] * web3.eth.gasPrice - - -def test_accounting_for_missed_execution_cancellation_by_owner(chain, - web3, - denoms, - RequestData, - get_cancel_data): - txn_request = RequestData( - windowStart=web3.eth.blockNumber + 255 + 10 + 5, - owner=web3.eth.accounts[1], - ).direct_deploy({ - 'from': web3.eth.accounts[1], - 'value': 10 * denoms.ether, - }) - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart + request_data.schedule.windowSize + 1 - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.accounts[1] - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - before_cancel_balance = web3.eth.getBalance(web3.eth.accounts[1]) - before_contract_balance = web3.eth.getBalance(txn_request.address) - - cancel_txn_hash = txn_request.transact({'from': web3.eth.accounts[1]}).cancel() - cancel_txn_receipt = chain.wait.for_receipt(cancel_txn_hash) - - after_cancel_balance = web3.eth.getBalance(web3.eth.accounts[1]) - after_contract_balance = web3.eth.getBalance(txn_request.address) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is True - - cancel_data = get_cancel_data(cancel_txn_hash) - # since this was cancelled by the owner. - assert cancel_data['args']['rewardPayment'] == 0 - assert cancel_data['args']['measuredGasConsumption'] == 0 - - assert before_contract_balance == 10 * denoms.ether - assert after_contract_balance == 0 - - assert after_cancel_balance - before_cancel_balance == 10 * denoms.ether - cancel_txn_receipt['gasUsed'] * web3.eth.gasPrice - - -def test_accounting_for_missed_execution_cancellation_not_by_owner(chain, - web3, - denoms, - RequestData, - get_cancel_data): - txn_request = RequestData( - windowStart=web3.eth.blockNumber + 255 + 10 + 5, - owner=web3.eth.coinbase, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - cancel_at = request_data.schedule.windowStart + request_data.schedule.windowSize + 1 - - # sanity - assert cancel_at > web3.eth.blockNumber - assert request_data.meta.owner == web3.eth.coinbase - assert request_data.meta.isCancelled is False - - chain.wait.for_block(cancel_at) - - before_cancel_balance = web3.eth.getBalance(web3.eth.accounts[1]) - before_contract_balance = web3.eth.getBalance(txn_request.address) - - cancel_txn_hash = txn_request.transact({'from': web3.eth.accounts[1]}).cancel() - cancel_txn_receipt = chain.wait.for_receipt(cancel_txn_hash) - - after_cancel_balance = web3.eth.getBalance(web3.eth.accounts[1]) - after_contract_balance = web3.eth.getBalance(txn_request.address) - - updated_request_data = RequestData.from_contract(txn_request) - assert updated_request_data.meta.isCancelled is True - - cancel_data = get_cancel_data(cancel_txn_hash) - measured_gas_consumption = cancel_data['args']['measuredGasConsumption'] - assert measured_gas_consumption >= cancel_txn_receipt['gasUsed'] - - assert cancel_data['args']['rewardPayment'] == measured_gas_consumption * web3.eth.gasPrice + updated_request_data.paymentData.payment // 100 - - assert before_contract_balance == 10 * denoms.ether - assert after_contract_balance == 0 - - assert after_cancel_balance - before_cancel_balance == cancel_data['args']['rewardPayment'] - cancel_txn_receipt['gasUsed'] * web3.eth.gasPrice diff --git a/populus-tests/transaction-request/test_cannot_execute_cancelled_request_check.py b/populus-tests/transaction-request/test_cannot_execute_cancelled_request_check.py deleted file mode 100644 index 89260c3bc..000000000 --- a/populus-tests/transaction-request/test_cannot_execute_cancelled_request_check.py +++ /dev/null @@ -1,42 +0,0 @@ -import pytest - - -def test_execution_rejected_if_cancelled(chain, - web3, - RequestData, - txn_recorder, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - windowStart=web3.eth.blockNumber + 20, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - assert request_data.meta.isCancelled is False - - cancel_txn_hash = txn_request.transact().cancel() - chain.wait.for_receipt(cancel_txn_hash) - - request_data.refresh() - assert request_data.meta.isCancelled is True - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_txn_hash = txn_request.transact({'gas': 3000000}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.WasCancelled in reasons diff --git a/populus-tests/transaction-request/test_digger_proxy.py b/populus-tests/transaction-request/test_digger_proxy.py deleted file mode 100644 index 058ae4573..000000000 --- a/populus-tests/transaction-request/test_digger_proxy.py +++ /dev/null @@ -1,31 +0,0 @@ -def test_digger_proxy_works_as_expected(chain, - web3, - txn_recorder, - digger_proxy): - assert txn_recorder.call().wasCalled() is False - - dig_txn_hash = digger_proxy.transact().__dig_then_proxy( - 1023, - txn_recorder.address, - 'the-call-data', - ) - chain.wait.for_receipt(dig_txn_hash) - - assert txn_recorder.call().wasCalled() is True - assert txn_recorder.call().lastCallData().startswith('the-call-data') - - -def test_digger_proxy_cannot_dig_past_1023(chain, - web3, - txn_recorder, - digger_proxy): - assert txn_recorder.call().wasCalled() is False - - dig_txn_hash = digger_proxy.transact().__dig_then_proxy( - 1024, - txn_recorder.address, - 'the-call-data', - ) - chain.wait.for_receipt(dig_txn_hash) - - assert txn_recorder.call().wasCalled() is False diff --git a/populus-tests/transaction-request/test_exceptions.py b/populus-tests/transaction-request/test_exceptions.py deleted file mode 100644 index 75b403074..000000000 --- a/populus-tests/transaction-request/test_exceptions.py +++ /dev/null @@ -1,75 +0,0 @@ -from web3.utils.encoding import decode_hex - - -def test_txn_request_for_txn_that_throw_exception(chain, - web3, - get_execute_data, - RequestData, - error_generator): - txn_request = RequestData( - createdBy=error_generator.address, - donation=12345, - toAddress=error_generator.address, - callData=decode_hex(error_generator._encode_transaction_data('doThrow')) - ).direct_deploy() - - request_data = RequestData.from_contract(txn_request) - chain.wait.for_block(request_data.schedule.windowStart) - - execute_txn_hash = txn_request.transact({ - 'from': web3.eth.accounts[1], - 'gas': 3000000, - }).execute() - execute_txn_receipt = chain.wait.for_receipt(execute_txn_hash) - - execute_data = get_execute_data(execute_txn_hash) - request_data = RequestData.from_contract(txn_request) - - assert request_data.meta.wasCalled is True - assert request_data.meta.wasSuccessful is False - - gas_used = execute_txn_receipt['gasUsed'] - measured_gas_consumption = execute_data['args']['measuredGasConsumption'] - - assert measured_gas_consumption > gas_used - assert measured_gas_consumption - gas_used < 120000 - - -def test_txn_request_when_everything_throws(chain, - web3, - get_execute_data, - RequestData, - error_generator): - txn_request = RequestData( - createdBy=error_generator.address, - owner=error_generator.address, - donationBenefactor=error_generator.address, - toAddress=error_generator.address, - callData=decode_hex(error_generator._encode_transaction_data('doThrow')) - ).direct_deploy() - - request_data = RequestData.from_contract(txn_request) - chain.wait.for_block(request_data.schedule.windowStart) - - proxy_call_data = decode_hex(txn_request._encode_transaction_data('execute')) - - execute_txn_hash = error_generator.transact({ - 'from': web3.eth.accounts[1], - 'gas': 3000000, - }).__proxy( - to=txn_request.address, - callData=proxy_call_data, - ) - execute_txn_receipt = chain.wait.for_receipt(execute_txn_hash) - - execute_data = get_execute_data(execute_txn_hash) - request_data = RequestData.from_contract(txn_request) - - assert request_data.meta.wasCalled is True - assert request_data.meta.wasSuccessful is False - - gas_used = execute_txn_receipt['gasUsed'] - measured_gas_consumption = execute_data['args']['measuredGasConsumption'] - - assert measured_gas_consumption > gas_used - assert measured_gas_consumption - gas_used < 50000 diff --git a/populus-tests/transaction-request/test_execution.py b/populus-tests/transaction-request/test_execution.py deleted file mode 100644 index 290d23866..000000000 --- a/populus-tests/transaction-request/test_execution.py +++ /dev/null @@ -1,30 +0,0 @@ -def test_transaction_sent_as_specified(chain, RequestData, txn_recorder): - txn_request = RequestData( - toAddress=txn_recorder.address, - callData='this-is-the-call-data', - callGas=123456, - callValue=121212, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert txn_recorder.call().lastCaller() == '0x0000000000000000000000000000000000000000' - assert txn_recorder.call().lastCallValue() == 0 - assert txn_recorder.call().lastCallGas() == 0 - assert txn_recorder.call().lastCallData() == '' - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_txn_hash = txn_request.transact({ - 'gas': 3000000, - }).execute() - chain.wait.for_receipt(execute_txn_hash) - - assert txn_recorder.call().wasCalled() is True - assert txn_recorder.call().lastCaller() == txn_request.address - assert txn_recorder.call().lastCallValue() == 121212 - assert txn_recorder.call().lastCallData().startswith('this-is-the-call-data') - assert len(txn_recorder.call().lastCallData()) == 32 - - call_gas_delta = abs(txn_recorder.call().lastCallGas() - 123456) - assert call_gas_delta < 10000 diff --git a/populus-tests/transaction-request/test_execution_gas_requirement_check.py b/populus-tests/transaction-request/test_execution_gas_requirement_check.py deleted file mode 100644 index 75f9d3d65..000000000 --- a/populus-tests/transaction-request/test_execution_gas_requirement_check.py +++ /dev/null @@ -1,162 +0,0 @@ -import pytest - -from web3.utils.encoding import ( - decode_hex, -) - - -def test_direct_execution_rejected_with_insufficient_gas(chain, - RequestData, - txn_recorder, - request_lib, - execution_lib, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - callGas=100000, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - - chain.wait.for_block(request_data.schedule.windowStart) - - minimum_call_gas = ( - request_data.txnData.callGas + - request_lib.call().EXECUTION_GAS_OVERHEAD() - ) - too_low_call_gas = minimum_call_gas - request_lib.call().PRE_EXECUTION_GAS() - - execute_txn_hash = txn_request.transact({'gas': too_low_call_gas}).execute() - chain.wait.for_receipt(execute_txn_hash) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.InsufficientGas in reasons - - -def test_direct_execution_accepted_with_minimum_gas(chain, - RequestData, - txn_recorder, - request_lib, - execution_lib, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - callGas=100000, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - - chain.wait.for_block(request_data.schedule.windowStart) - - minimum_call_gas = ( - request_data.txnData.callGas + - request_lib.call().EXECUTION_GAS_OVERHEAD() - ) - - execute_txn_hash = txn_request.transact({'gas': minimum_call_gas}).execute() - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert txn_recorder.call().wasCalled() is True - assert request_data.meta.wasCalled is True - - assert get_execute_data(execute_txn_hash) - - -def test_proxy_execution_rejected_for_insufficient_gas(chain, - RequestData, - proxy, - txn_recorder, - request_lib, - execution_lib, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - callGas=100000, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - - chain.wait.for_block(request_data.schedule.windowStart) - - minimum_call_gas = ( - request_data.txnData.callGas + - request_lib.call().EXECUTION_GAS_OVERHEAD() + - execution_lib.call().GAS_PER_DEPTH() * request_data.txnData.requiredStackDepth - ) - too_low_call_gas = minimum_call_gas - request_lib.call().PRE_EXECUTION_GAS() - - call_data_hex = txn_request._encode_transaction_data('execute') - execute_txn_hash = proxy.transact({'gas': 3000000}).__proxy( - to=txn_request.address, - callData=decode_hex(call_data_hex), - callGas=too_low_call_gas, - ) - chain.wait.for_receipt(execute_txn_hash) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.InsufficientGas in reasons - - -def test_proxy_execution_accepted_at_minimum_gas(chain, - RequestData, - proxy, - txn_recorder, - request_lib, - execution_lib, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - callGas=100000, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - - chain.wait.for_block(request_data.schedule.windowStart) - - minimum_call_gas = ( - request_data.txnData.callGas + - request_lib.call().EXECUTION_GAS_OVERHEAD() + - execution_lib.call().GAS_PER_DEPTH() * request_data.txnData.requiredStackDepth - ) - - call_data_hex = txn_request._encode_transaction_data('execute') - execute_txn_hash = proxy.transact({'gas': 3000000}).__proxy( - to=txn_request.address, - callData=decode_hex(call_data_hex), - callGas=minimum_call_gas, - ) - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert get_execute_data(execute_txn_hash) - assert txn_recorder.call().wasCalled() is True - assert request_data.meta.wasCalled is True diff --git a/populus-tests/transaction-request/test_stack_depth_check.py b/populus-tests/transaction-request/test_stack_depth_check.py deleted file mode 100644 index c7259ea73..000000000 --- a/populus-tests/transaction-request/test_stack_depth_check.py +++ /dev/null @@ -1,86 +0,0 @@ -import pytest - -from web3.utils.encoding import ( - decode_hex, -) - - -def test_execution_rejected_if_stack_too_deep(chain, - web3, - RequestData, - txn_recorder, - digger_proxy, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - requiredStackDepth=1000, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - assert request_data.txnData.requiredStackDepth == 1000 - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_call_data = decode_hex(txn_request._encode_transaction_data('execute')) - - execute_txn_hash = digger_proxy.transact({'gas': 3000000}).__dig_then_proxy( - 24, - txn_request.address, - execute_call_data, - ) - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert digger_proxy.call().result() is True - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - - with pytest.raises(AssertionError): - get_execute_data(execute_txn_hash) - - abort_data = get_abort_data(execute_txn_hash) - reasons = {entry['args']['reason'] for entry in abort_data} - assert AbortReasons.StackTooDeep in reasons - - -def test_execution_accepted_when_stack_extendable(chain, - web3, - RequestData, - txn_recorder, - digger_proxy, - get_execute_data, - get_abort_data, - AbortReasons): - txn_request = RequestData( - toAddress=txn_recorder.address, - requiredStackDepth=1000, - ).direct_deploy() - request_data = RequestData.from_contract(txn_request) - - assert txn_recorder.call().wasCalled() is False - assert request_data.meta.wasCalled is False - assert request_data.txnData.requiredStackDepth == 1000 - - chain.wait.for_block(request_data.schedule.windowStart) - - execute_call_data = decode_hex(txn_request._encode_transaction_data('execute')) - - execute_txn_hash = digger_proxy.transact({'gas': 3000000}).__dig_then_proxy( - 21, - txn_request.address, - execute_call_data, - ) - chain.wait.for_receipt(execute_txn_hash) - - request_data.refresh() - - assert digger_proxy.call().result() is True - assert txn_recorder.call().wasCalled() is True - assert request_data.meta.wasCalled is True - - assert get_execute_data(execute_txn_hash)