def get_latest_block_height(driver: ContractDriver):
h = driver.get(BLOCK_NUM_HEIGHT, mark=False)
if h is None:
return 0
if type(h) == ContractingDecimal:
h = int(h._d)
return h
class TestMetering(TestCase):
def setUp(self):
# Hard load the submission contract
self.d = ContractDriver()
self.d.flush()
with open(contracting.__path__[0] + '/contracts/submission.s.py') as f:
contract = f.read()
self.d.set_contract(name='submission', code=contract)
self.d.commit()
# Execute the currency contract with metering disabled
self.e = Executor(driver=self.d)
self.e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/currency.s.py'),
metering=False,
auto_commit=True)
def tearDown(self):
self.d.flush()
def test_simple_execution_deducts_stamps(self):
prior_balance = self.d.get('currency.balances:stu')
output = self.e.execute('stu',
'currency',
'transfer',
kwargs={
'amount': 100,
'to': 'colin'
},
auto_commit=True)
new_balance = self.d.get('currency.balances:stu')
self.assertEqual(float(prior_balance - new_balance - 100),
output['stamps_used'] / STAMPS_PER_TAU)
def test_too_few_stamps_fails_and_deducts_properly(self):
prior_balance = self.d.get('currency.balances:stu')
print(prior_balance)
small_amount_of_stamps = 1 * STAMPS_PER_TAU
output = self.e.execute('stu',
'currency',
'transfer',
kwargs={
'amount': 100,
'to': 'colin'
},
stamps=small_amount_of_stamps,
auto_commit=True)
print(output)
new_balance = self.d.get('currency.balances:stu')
self.assertEqual(float(prior_balance - new_balance),
output['stamps_used'] / STAMPS_PER_TAU)
def test_adding_too_many_stamps_throws_error(self):
prior_balance = self.d.get('currency.balances:stu')
too_many_stamps = (prior_balance + 1000) * STAMPS_PER_TAU
output = self.e.execute('stu',
'currency',
'transfer',
kwargs={
'amount': 100,
'to': 'colin'
},
stamps=too_many_stamps,
auto_commit=True)
self.assertEqual(output['status_code'], 1)
def test_adding_all_stamps_with_infinate_loop_eats_all_balance(self):
self.d.set('currency.balances:stu', 500)
self.d.commit()
prior_balance = self.d.get('currency.balances:stu')
prior_balance *= STAMPS_PER_TAU
self.e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/inf_loop.s.py'),
stamps=prior_balance,
metering=True,
auto_commit=True)
new_balance = self.d.get('currency.balances:stu')
# Not all stamps will be deducted because it will blow up in the middle of execution
self.assertTrue(new_balance < 0.01)
def test_submitting_contract_succeeds_with_enough_stamps(self):
prior_balance = self.d.get('currency.balances:stu')
print(prior_balance)
output = self.e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/erc20_clone.s.py'),
auto_commit=True)
print(output)
new_balance = self.d.get('currency.balances:stu')
print(new_balance)
self.assertEqual(float(prior_balance - new_balance),
output['stamps_used'] / STAMPS_PER_TAU)
def test_pending_writes_has_deducted_stamp_amount_prior_to_auto_commit(
self):
prior_balance = self.d.get('currency.balances:stu')
output = self.e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/erc20_clone.s.py'),
auto_commit=False)
self.assertNotEquals(
self.e.driver.pending_writes['currency.balances:stu'],
prior_balance)
def get_latest_block_hash(driver: ContractDriver):
latest_hash = driver.get(BLOCK_HASH_KEY, mark=False)
if latest_hash is None:
return '0' * 64
return latest_hash
class TestExecutor(TestCase):
def setUp(self):
self.d = ContractDriver()
self.d.flush()
with open('../../contracting/contracts/submission.s.py') as f:
contract = f.read()
self.d.set_contract(name='submission', code=contract)
self.d.commit()
self.compiler = ContractingCompiler()
def tearDown(self):
self.d.flush()
def test_submission(self):
e = Executor(metering=False)
code = '''@export
def d():
a = 1
return 1
'''
kwargs = {'name': 'stubucks', 'code': code}
e.execute(**TEST_SUBMISSION_KWARGS, kwargs=kwargs, auto_commit=True)
self.compiler.module_name = 'stubucks'
new_code = self.compiler.parse_to_code(code)
self.assertEqual(self.d.get_contract('stubucks'), new_code)
def test_submission_then_function_call(self):
e = Executor(metering=False)
code = '''@export
def d():
return 1
'''
kwargs = {'name': 'stubuckz', 'code': code}
e.execute(**TEST_SUBMISSION_KWARGS, kwargs=kwargs)
output = e.execute(sender='stu',
contract_name='stubuckz',
function_name='d',
kwargs={})
self.assertEqual(output['result'], 1)
self.assertEqual(output['status_code'], 0)
def test_kwarg_helper(self):
k = submission_kwargs_for_file(
'./test_contracts/test_orm_variable_contract.s.py')
code = '''v = Variable()
@export
def set_v(i: int):
v.set(i)
@export
def get_v():
return v.get()
'''
self.assertEqual(k['name'], 'test_orm_variable_contract')
self.assertEqual(k['code'], code)
def test_orm_variable_sets_in_contract(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_variable_contract.s.py'),
auto_commit=True)
e.execute('stu',
'test_orm_variable_contract',
'set_v',
kwargs={'i': 1000},
auto_commit=True)
i = self.d.get('test_orm_variable_contract.v')
self.assertEqual(i, 1000)
def test_orm_variable_gets_in_contract(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_variable_contract.s.py'))
res = e.execute('stu',
'test_orm_variable_contract',
'get_v',
kwargs={})
self.assertEqual(res['result'], None)
def test_orm_variable_gets_and_sets_in_contract(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_variable_contract.s.py'))
e.execute('stu',
'test_orm_variable_contract',
'set_v',
kwargs={'i': 1000})
res = e.execute('stu',
'test_orm_variable_contract',
'get_v',
kwargs={})
self.assertEqual(res['result'], 1000)
def test_orm_hash_sets_in_contract(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_hash_contract.s.py'),
auto_commit=True)
e.execute('stu',
'test_orm_hash_contract',
'set_h',
kwargs={
'k': 'key1',
'v': 1234
},
auto_commit=True)
e.execute('stu',
'test_orm_hash_contract',
'set_h',
kwargs={
'k': 'another_key',
'v': 9999
},
auto_commit=True)
key1 = self.d.get('test_orm_hash_contract.h:key1')
another_key = self.d.get('test_orm_hash_contract.h:another_key')
self.assertEqual(key1, 1234)
self.assertEqual(another_key, 9999)
def test_orm_hash_gets_in_contract(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_hash_contract.s.py'))
res = e.execute('stu',
'test_orm_hash_contract',
'get_h',
kwargs={'k': 'test'})
self.assertEqual(res['result'], None)
def test_orm_hash_gets_and_sets_in_contract(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_hash_contract.s.py'))
e.execute('stu',
'test_orm_hash_contract',
'set_h',
kwargs={
'k': 'key1',
'v': 1234
})
e.execute('stu',
'test_orm_hash_contract',
'set_h',
kwargs={
'k': 'another_key',
'v': 9999
})
key1 = e.execute('stu',
'test_orm_hash_contract',
'get_h',
kwargs={'k': 'key1'})
another_key = e.execute('stu',
'test_orm_hash_contract',
'get_h',
kwargs={'k': 'another_key'})
self.assertEqual(key1['result'], 1234)
self.assertEqual(another_key['result'], 9999)
def test_orm_foreign_variable_sets_in_contract_doesnt_work(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_variable_contract.s.py'))
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_foreign_key_contract.s.py'))
e.execute('stu',
'test_orm_variable_contract',
'set_v',
kwargs={'i': 1000})
# this should fail
status = e.execute('stu',
'test_orm_foreign_key_contract',
'set_fv',
kwargs={'i': 999})
self.assertEqual(status['status_code'], 1)
i = e.execute('stu', 'test_orm_variable_contract', 'get_v', kwargs={})
self.assertEqual(i['result'], 1000)
def test_orm_foreign_variable_gets_in_contract(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_variable_contract.s.py'))
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_foreign_key_contract.s.py'))
e.execute('stu',
'test_orm_variable_contract',
'set_v',
kwargs={'i': 424242})
# this should fail
i = e.execute('stu',
'test_orm_foreign_key_contract',
'get_fv',
kwargs={})
self.assertEqual(i['result'], 424242)
def test_orm_foreign_hash_sets_in_contract_doesnt_work(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_hash_contract.s.py'),
auto_commit=True)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_foreign_hash_contract.s.py'),
auto_commit=True)
e.execute('stu',
'test_orm_hash_contract',
'set_h',
kwargs={
'k': 'key1',
'v': 1234
},
auto_commit=True)
e.execute('stu',
'test_orm_hash_contract',
'set_h',
kwargs={
'k': 'another_key',
'v': 9999
},
auto_commit=True)
status_1 = e.execute('stu',
'test_orm_foreign_hash_contract',
'set_fh',
kwargs={
'k': 'key1',
'v': 5555
},
auto_commit=True)
status_2 = e.execute('stu',
'test_orm_foreign_hash_contract',
'set_fh',
kwargs={
'k': 'another_key',
'v': 1000
},
auto_commit=True)
key1 = self.d.get('test_orm_hash_contract.h:key1')
another_key = self.d.get('test_orm_hash_contract.h:another_key')
self.assertEqual(key1, 1234)
self.assertEqual(another_key, 9999)
self.assertEqual(status_1['status_code'], 1)
self.assertEqual(status_2['status_code'], 1)
def test_orm_foreign_hash_gets_and_sets_in_contract(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_hash_contract.s.py'))
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_foreign_hash_contract.s.py'))
e.execute('stu',
'test_orm_hash_contract',
'set_h',
kwargs={
'k': 'key1',
'v': 1234
})
e.execute('stu',
'test_orm_hash_contract',
'set_h',
kwargs={
'k': 'another_key',
'v': 9999
})
key1 = e.execute('stu',
'test_orm_foreign_hash_contract',
'get_fh',
kwargs={'k': 'key1'})
another_key = e.execute('stu',
'test_orm_foreign_hash_contract',
'get_fh',
kwargs={'k': 'another_key'})
self.assertEqual(key1['result'], 1234)
self.assertEqual(another_key['result'], 9999)
def test_orm_contract_not_accessible(self):
e = Executor(metering=False)
output = e.execute(
**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_orm_no_contract_access.s.py'))
self.assertIsInstance(output['result'], Exception)
def test_construct_function_sets_properly(self):
e = Executor(metering=False)
r = e.execute(
**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/test_construct_function_works.s.py'))
output = e.execute('stu',
'test_construct_function_works',
'get',
kwargs={})
self.assertEqual(output['result'], 42)
def test_import_exported_function_works(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/import_this.s.py'))
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/importing_that.s.py'))
output = e.execute('stu', 'importing_that', 'test', kwargs={})
self.assertEqual(output['result'], 12345 - 1000)
def test_arbitrary_environment_passing_works_via_executor(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/i_use_env.s.py'))
this_is_a_passed_in_variable = 555
env = {'this_is_a_passed_in_variable': this_is_a_passed_in_variable}
output = e.execute('stu',
'i_use_env',
'env_var',
kwargs={},
environment=env)
self.assertEqual(output['result'], this_is_a_passed_in_variable)
def test_arbitrary_environment_passing_fails_if_not_passed_correctly(self):
e = Executor(metering=False)
e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file(
'./test_contracts/i_use_env.s.py'))
this_is_a_passed_in_variable = 555
env = {
'this_is_another_passed_in_variable': this_is_a_passed_in_variable
}
output = e.execute('stu',
'i_use_env',
'env_var',
kwargs={},
environment=env)
self.assertEqual(output['status_code'], 1)
class TestAtomicSwapContract(TestCase):
def setUp(self):
self.d = ContractDriver()
self.d.flush()
with open(contracting.__path__[0] + '/contracts/submission.s.py') as f:
contract = f.read()
self.d.set_contract(name='submission',
code=contract)
self.d.commit()
self.e = Executor(currency_contract='erc20_clone', metering=False)
environment = {'now': Datetime(2019, 1, 1)}
self.e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file('./test_contracts/erc20_clone.s.py'), environment=environment)
self.e.execute(**TEST_SUBMISSION_KWARGS,
kwargs=submission_kwargs_for_file('./test_contracts/atomic_swaps.s.py'))
def tearDown(self):
self.e.bypass_privates = False
self.d.flush()
def test_initiate_not_enough_approved(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
output = self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5000000
})
self.assertEqual(output['status_code'], 1)
self.assertTrue(isinstance(output['result'], AssertionError))
def test_initiate_transfers_coins_correctly(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
atomic_swaps = self.e.execute('stu', 'erc20_clone', 'balance_of', kwargs={'account':'atomic_swaps'})
stu = self.e.execute('stu', 'erc20_clone', 'balance_of', kwargs={'account': 'stu'})
stu_as = self.e.execute('stu', 'erc20_clone', 'allowance', kwargs={'owner': 'stu', 'spender': 'atomic_swaps'})
self.assertEqual(atomic_swaps['result'], 5)
self.assertEqual(stu['result'], 999995)
self.assertEqual(stu_as['result'], 999995)
def test_initiate_writes_to_correct_key_and_properly(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'}, auto_commit=True)
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
}, auto_commit=True)
key = 'atomic_swaps.swaps:raghu:eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514'
expiration, amount = self.d.get(key)
self.assertEqual(expiration, Datetime(2020, 1, 1))
self.assertEqual(amount, 5)
def test_redeem_on_wrong_secret_fails(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
output = self.e.execute('raghu', 'atomic_swaps', 'redeem', kwargs={'secret': '00'})
self.assertEqual(output['status_code'], 1)
self.assertEqual(str(output['result']), 'Incorrect sender or secret passed.')
def test_redeem_on_wrong_sender_fails(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
output = self.e.execute('stu', 'atomic_swaps', 'redeem', kwargs={'secret': '842b65a7d48e3a3c3f0e9d37eaced0b2'})
# status_code, result, stamps_used
self.assertEqual(output['status_code'], 1)
self.assertEqual(str(output['result']), 'Incorrect sender or secret passed.')
def test_past_expiration_fails(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
environment = {'now': Datetime(2021, 1, 1)}
output = self.e.execute('raghu', 'atomic_swaps', 'redeem', kwargs={'secret': '842b65a7d48e3a3c3f0e9d37eaced0b2'},
environment=environment)
self.assertEqual(output['status_code'], 1)
self.assertEqual(str(output['result']), 'Swap has expired.')
def test_successful_redeem_transfers_coins_correctly(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
environment = {'now': Datetime(2019, 1, 1)}
self.e.execute('raghu', 'atomic_swaps', 'redeem', kwargs={'secret': '842b65a7d48e3a3c3f0e9d37eaced0b2'},
environment=environment)
atomic_swaps = self.e.execute('stu', 'erc20_clone', 'balance_of', kwargs={'account': 'atomic_swaps'})
raghu = self.e.execute('stu', 'erc20_clone', 'balance_of', kwargs={'account': 'raghu'})
self.assertEqual(raghu['result'], 5)
self.assertEqual(atomic_swaps['result'], 0)
def test_successful_redeem_deletes_entry(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
environment = {'now': Datetime(2019, 1, 1)}
self.e.execute('raghu', 'atomic_swaps', 'redeem', kwargs={'secret': '842b65a7d48e3a3c3f0e9d37eaced0b2'},
environment=environment)
key = 'atomic_swaps.swaps:raghu:eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514'
v = self.d.get(key)
self.assertEqual(v, None)
def test_refund_works(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
environment = {'now': Datetime(2021, 1, 1)}
self.e.execute('stu', 'atomic_swaps', 'refund', kwargs={'participant': 'raghu', 'secret': '842b65a7d48e3a3c3f0e9d37eaced0b2'},
environment=environment)
atomic_swaps = self.e.execute('stu', 'erc20_clone', 'balance_of', kwargs={'account': 'atomic_swaps'})
stu = self.e.execute('stu', 'erc20_clone', 'balance_of', kwargs={'account': 'stu'})
self.assertEqual(stu['result'], 1000000)
self.assertEqual(atomic_swaps['result'], 0)
def test_refund_too_early_fails(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
environment = {'now': Datetime(2019, 1, 1)}
res = self.e.execute('stu', 'atomic_swaps', 'refund',
kwargs={'participant': 'raghu', 'secret': '842b65a7d48e3a3c3f0e9d37eaced0b2'},
environment=environment)
self.assertEqual(str(res['result']), 'Swap has not expired.')
def test_refund_participant_is_signer_fails(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
environment = {'now': Datetime(2021, 1, 1)}
res = self.e.execute('raghu', 'atomic_swaps', 'refund',
kwargs={'participant': 'raghu', 'secret': '842b65a7d48e3a3c3f0e9d37eaced0b2'},
environment=environment)
self.assertEqual(str(res['result']), 'Caller and signer cannot issue a refund.')
def test_refund_fails_with_wrong_secret(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
environment = {'now': Datetime(2019, 1, 1)}
res = self.e.execute('stu', 'atomic_swaps', 'refund',
kwargs={'participant': 'raghu', 'secret': '00'},
environment=environment)
self.assertEqual(str(res['result']), 'No swap to refund found.')
def test_refund_resets_swaps(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
environment = {'now': Datetime(2021, 1, 1)}
self.e.execute('stu', 'atomic_swaps', 'refund',
kwargs={'participant': 'raghu', 'secret': '842b65a7d48e3a3c3f0e9d37eaced0b2'},
environment=environment)
key = 'atomic_swaps.swaps:raghu:eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514'
v = self.d.get(key)
self.assertEqual(v, None)
def test_trying_to_call_private_function_fails(self):
with self.assertRaises(AssertionError):
self.e.execute('stu', 'atomic_swaps', '__test', kwargs={})
self.e.bypass_privates = True
self.e.execute('stu', 'atomic_swaps', '__test', kwargs={})
class TestUpdatingState(TestCase):
def setUp(self):
self.driver = ContractDriver()
self.nonces = storage.NonceStorage()
self.nonces.flush()
self.driver.flush()
self.driver.clear_pending_state()
def tearDown(self):
self.nonces.flush()
self.driver.flush()
self.driver.clear_pending_state()
def test_state_updated_to_correct_values_in_tx(self):
v1 = self.driver.get('hello', mark=False)
v2 = self.driver.get('name', mark=False)
self.assertIsNone(v1)
self.assertIsNone(v2)
storage.update_state_with_transaction(tx=tx_1,
driver=self.driver,
nonces=self.nonces)
v1 = self.driver.get('hello', mark=False)
v2 = self.driver.get('name', mark=False)
self.assertEqual(v1, 'there')
self.assertEqual(v2, 'jeff')
def test_nonces_set_to_tx_value(self):
n = self.nonces.get_latest_nonce(sender='abc', processor='def')
self.assertEqual(n, 0)
storage.update_state_with_transaction(tx=tx_1,
driver=self.driver,
nonces=self.nonces)
n = self.nonces.get_latest_nonce(sender='abc', processor='def')
self.assertEqual(n, 124)
def test_nonces_deleted_after_all_updates(self):
self.nonces.set_pending_nonce(sender='abc', processor='def', value=122)
n = self.nonces.get_pending_nonce(sender='abc', processor='def')
self.assertEqual(n, 122)
storage.update_state_with_transaction(tx=tx_1,
driver=self.driver,
nonces=self.nonces)
n = self.nonces.get_pending_nonce(sender='abc', processor='def')
self.assertEqual(n, None)
def test_multiple_txs_deletes_multiple_nonces(self):
self.nonces.set_pending_nonce(sender='abc', processor='def', value=122)
n = self.nonces.get_pending_nonce(sender='abc', processor='def')
self.assertEqual(n, 122)
self.nonces.set_pending_nonce(sender='xxx', processor='yyy', value=4)
n = self.nonces.get_pending_nonce(sender='xxx', processor='yyy')
self.assertEqual(n, 4)
storage.update_state_with_transaction(tx=tx_1,
driver=self.driver,
nonces=self.nonces)
storage.update_state_with_transaction(tx=tx_2,
driver=self.driver,
nonces=self.nonces)
storage.update_state_with_transaction(tx=tx_3,
driver=self.driver,
nonces=self.nonces)
n = self.nonces.get_pending_nonce(sender='abc', processor='def')
self.assertEqual(n, None)
n = self.nonces.get_pending_nonce(sender='xxx', processor='yyy')
self.assertEqual(n, None)
n = self.nonces.get_latest_nonce(sender='abc', processor='def')
self.assertEqual(n, 125)
n = self.nonces.get_latest_nonce(sender='xxx', processor='yyy')
self.assertEqual(n, 43)
def test_multiple_tx_state_updates_correctly(self):
v1 = self.driver.get('hello', mark=False)
v2 = self.driver.get('name', mark=False)
v3 = self.driver.get('name2', mark=False)
v4 = self.driver.get('another', mark=False)
v5 = self.driver.get('something', mark=False)
self.assertIsNone(v1)
self.assertIsNone(v2)
self.assertIsNone(v3)
self.assertIsNone(v4)
self.assertIsNone(v5)
storage.update_state_with_transaction(tx=tx_1,
driver=self.driver,
nonces=self.nonces)
storage.update_state_with_transaction(tx=tx_2,
driver=self.driver,
nonces=self.nonces)
storage.update_state_with_transaction(tx=tx_3,
driver=self.driver,
nonces=self.nonces)
v1 = self.driver.get('hello', mark=False)
v2 = self.driver.get('name', mark=False)
v3 = self.driver.get('name2', mark=False)
v4 = self.driver.get('another', mark=False)
v5 = self.driver.get('something', mark=False)
self.assertEqual(v1, 'there2')
self.assertEqual(v2, 'jeff')
self.assertEqual(v3, 'jeff2')
self.assertEqual(v4, 'value')
self.assertEqual(v5, 'else')
def test_update_with_block_sets_hash_and_height(self):
_hash = storage.get_latest_block_hash(self.driver)
num = storage.get_latest_block_height(self.driver)
self.assertEqual(_hash, '0' * 64)
self.assertEqual(num, 0)
storage.update_state_with_block(block=block,
driver=self.driver,
nonces=self.nonces)
_hash = storage.get_latest_block_hash(self.driver)
num = storage.get_latest_block_height(self.driver)
self.assertEqual(_hash, 'f' * 64)
self.assertEqual(num, 555)
def test_update_with_block_sets_nonces_correctly(self):
self.nonces.set_pending_nonce(sender='abc', processor='def', value=122)
n = self.nonces.get_pending_nonce(sender='abc', processor='def')
self.assertEqual(n, 122)
self.nonces.set_pending_nonce(sender='xxx', processor='yyy', value=4)
n = self.nonces.get_pending_nonce(sender='xxx', processor='yyy')
self.assertEqual(n, 4)
storage.update_state_with_block(block=block,
driver=self.driver,
nonces=self.nonces)
n = self.nonces.get_pending_nonce(sender='abc', processor='def')
self.assertEqual(n, None)
n = self.nonces.get_pending_nonce(sender='xxx', processor='yyy')
self.assertEqual(n, None)
n = self.nonces.get_latest_nonce(sender='abc', processor='def')
self.assertEqual(n, 125)
n = self.nonces.get_latest_nonce(sender='xxx', processor='yyy')
self.assertEqual(n, 43)
def test_update_state_with_block_sets_state_correctly(self):
v1 = self.driver.get('hello', mark=False)
v2 = self.driver.get('name', mark=False)
v3 = self.driver.get('name2', mark=False)
v4 = self.driver.get('another', mark=False)
v5 = self.driver.get('something', mark=False)
self.assertIsNone(v1)
self.assertIsNone(v2)
self.assertIsNone(v3)
self.assertIsNone(v4)
self.assertIsNone(v5)
storage.update_state_with_block(block=block,
driver=self.driver,
nonces=self.nonces)
v1 = self.driver.get('hello', mark=False)
v2 = self.driver.get('name', mark=False)
v3 = self.driver.get('name2', mark=False)
v4 = self.driver.get('another', mark=False)
v5 = self.driver.get('something', mark=False)
self.assertEqual(v1, 'there2')
self.assertEqual(v2, 'jeff')
self.assertEqual(v3, 'jeff2')
self.assertEqual(v4, 'value')
self.assertEqual(v5, 'else')
def get_latest_block_height(driver: ContractDriver):
h = driver.get(BLOCK_NUM_HEIGHT, mark=False)
if h is None:
return 0
return h
