def test_transaction_is_valid_complete_test_passes(self):
w = Wallet()
tx = build_transaction(wallet=w,
processor='b' * 64,
stamps=123,
nonce=0,
contract='currency',
function='transfer',
kwargs={
'amount': 123,
'to': 'jeff'
})
decoded = decode(tx)
client = ContractingClient()
client.flush()
client.set_var(contract='currency',
variable='balances',
arguments=[w.verifying_key],
value=1_000_000)
client.set_var(contract='stamp_cost',
variable='S',
arguments=['value'],
value=20_000)
transaction.transaction_is_valid(transaction=decoded,
expected_processor='b' * 64,
client=client,
nonces=self.driver)
def add_to_balance(vk, amount, client: ContractingClient):
current_balance = client.get_var(contract='currency',
variable='balances',
arguments=[vk],
mark=False)
if current_balance is None:
current_balance = ContractingDecimal(0)
amount = ContractingDecimal(amount)
client.set_var(contract='currency',
variable='balances',
arguments=[vk],
value=amount + current_balance,
mark=True)
class TestRewards(TestCase):
def setUp(self):
self.client = ContractingClient()
self.rewards = rewards.RewardManager()
def tearDown(self):
self.client.flush()
def sync(self):
sync.setup_genesis_contracts(['stu', 'raghu', 'steve'],
['tejas', 'alex2'],
client=self.client)
def test_contract_exists_false_before_sync(self):
self.assertFalse(
self.rewards.contract_exists('stamp_cost', self.client))
def test_contract_exists_true_after_sync(self):
# Sync contracts
self.sync()
self.assertTrue(self.rewards.contract_exists('stamp_cost',
self.client))
def test_is_setup_false_before_sync(self):
self.assertFalse(self.rewards.is_setup(self.client))
def test_is_setup_true_after_sync(self):
self.sync()
self.assertTrue(self.rewards.is_setup(self.client))
def test_add_to_balance_if_none_sets(self):
self.rewards.add_to_balance('stu', 123, self.client)
bal = self.client.get_var('currency',
variable='balances',
arguments=['stu'])
self.assertEqual(bal, 123)
def test_add_to_balance_twice_sets_accordingly(self):
self.rewards.add_to_balance('stu', 123, self.client)
bal = self.client.get_var('currency',
variable='balances',
arguments=['stu'])
self.assertEqual(bal, 123)
self.rewards.add_to_balance('stu', 123, self.client)
bal = self.client.get_var('currency',
variable='balances',
arguments=['stu'])
self.assertEqual(bal, 246)
def test_calculate_rewards_returns_accurate_amounts_per_participant_group(
self):
self.sync()
self.client.set_var(contract='rewards',
variable='S',
arguments=['value'],
value=[0.4, 0.3, 0.1, 0.1, 0.1])
m, d, f, mapping = self.rewards.calculate_all_rewards(
client=self.client, block=BLOCK)
reconstructed = (m * 3) + (d * 2) + (f * 1) + (f * 1) + (f * 1)
self.assertAlmostEqual(reconstructed,
self.rewards.stamps_in_block(BLOCK))
def test_calculate_participant_reward_shaves_off_dust(self):
rounded_reward = self.rewards.calculate_participant_reward(
participant_ratio=1,
number_of_participants=1,
total_stamps_to_split=1.0000000000001)
self.assertEqual(rounded_reward, 1)
def test_distribute_rewards_adds_to_all_wallets(self):
self.sync()
self.client.set_var(contract='rewards',
variable='S',
arguments=['value'],
value=[0.4, 0.3, 0.1, 0.1, 0.1])
self.client.set_var(contract='foundation',
variable='owner',
value='xxx')
self.client.set_var(contract='stamp_cost',
variable='S',
arguments=['value'],
value=100)
self.client.set_var(contract='thing_1',
variable='__developer__',
value='stu2')
self.client.set_var(contract='thing_2',
variable='__developer__',
value='jeff')
self.client.set_var(contract='thing_3',
variable='__developer__',
value='alex')
total_tau_to_split = 4900
m, d, f, mapping = self.rewards.calculate_all_rewards(
client=self.client, block=BLOCK)
self.rewards.distribute_rewards(m, d, f, mapping, client=self.client)
masters = self.client.get_var(contract='masternodes',
variable='S',
arguments=['members'])
delegates = self.client.get_var(contract='delegates',
variable='S',
arguments=['members'])
for mn in masters:
current_balance = self.client.get_var(contract='currency',
variable='balances',
arguments=[mn],
mark=False)
self.assertEqual(current_balance, m / 100)
for dl in delegates:
current_balance = self.client.get_var(contract='currency',
variable='balances',
arguments=[dl],
mark=False)
self.assertEqual(current_balance, d / 100)
current_balance = self.client.get_var(contract='currency',
variable='balances',
arguments=['xxx'],
mark=False)
self.assertEqual(current_balance, f / 100)
def test_stamps_in_block(self):
block = {
'number':
2,
'subblocks': [{
'transactions': [{
'stamps_used': 1000
}, {
'stamps_used': 2000
}, {
'stamps_used': 3000
}]
}, {
'transactions': [{
'stamps_used': 4500
}, {
'stamps_used': 1250
}, {
'stamps_used': 2750
}]
}]
}
self.assertEqual(self.rewards.stamps_in_block(block), 14500)
def test_issue_rewards_full_loop_works(self):
self.sync()
self.client.set_var(contract='rewards',
variable='S',
arguments=['value'],
value=[0.4, 0.3, 0.1, 0.1, 0.1])
self.client.set_var(contract='foundation',
variable='owner',
value='xxx')
self.client.set_var(contract='stamp_cost',
variable='S',
arguments=['value'],
value=100)
self.client.set_var(contract='thing_1',
variable='__developer__',
value='stu2')
self.client.set_var(contract='thing_2',
variable='__developer__',
value='jeff')
self.client.set_var(contract='thing_3',
variable='__developer__',
value='alex')
block = {
'number':
1,
'subblocks': [{
'transactions': [{
'stamps_used': 1000,
'transaction': {
'payload': {
'contract': 'thing_1'
}
}
}, {
'stamps_used': 2000,
'transaction': {
'payload': {
'contract': 'thing_2'
}
}
}, {
'stamps_used': 3000,
'transaction': {
'payload': {
'contract': 'thing_3'
}
}
}]
}, {
'transactions': [{
'stamps_used': 4500,
'transaction': {
'payload': {
'contract': 'thing_1'
}
}
}, {
'stamps_used': 1250,
'transaction': {
'payload': {
'contract': 'thing_1'
}
}
}, {
'stamps_used': 2750,
'transaction': {
'payload': {
'contract': 'thing_2'
}
}
}]
}]
}
# tau to distribute should be 145
stamps = self.rewards.stamps_in_block(block)
tau = stamps / 100
self.assertEqual(tau, 145)
self.rewards.issue_rewards(block, client=self.client)
# Stu is owed: 6750 stamps / 100 / 3 =
# Jeff is owed: 4750 stamps / 100 / 3= 47.5
# Alex is owed:
m, d, f, mapping = self.rewards.calculate_all_rewards(
client=self.client, block=block)
masters = self.client.get_var(contract='masternodes',
variable='S',
arguments=['members'])
delegates = self.client.get_var(contract='delegates',
variable='S',
arguments=['members'])
for mn in masters:
current_balance = self.client.get_var(contract='currency',
variable='balances',
arguments=[mn],
mark=False)
self.assertEqual(current_balance, m / 100)
for dl in delegates:
current_balance = self.client.get_var(contract='currency',
variable='balances',
arguments=[dl],
mark=False)
self.assertEqual(current_balance, d / 100)
current_balance = self.client.get_var(contract='currency',
variable='balances',
arguments=['xxx'],
mark=False)
self.assertEqual(current_balance, f / 100)
for dev in mapping.keys():
current_balance = self.client.get_var(contract='currency',
variable='balances',
arguments=[dev],
mark=False)
self.assertAlmostEqual(current_balance, mapping[dev] / 100)
class TestMiscContracts(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.raw_driver.flush()
with open('../../contracting/contracts/submission.s.py') as f:
contract = f.read()
self.c.raw_driver.set_contract(name='submission', code=contract,)
self.c.raw_driver.commit()
submission = self.c.get_contract('submission')
self.c.submit(too_many_writes)
# submit erc20 clone
with open('./test_contracts/thing.s.py') as f:
code = f.read()
self.c.submit(code, name='thing')
with open('./test_contracts/foreign_thing.s.py') as f:
code = f.read()
self.c.submit(code, name='foreign_thing')
self.thing = self.c.get_contract('thing')
self.foreign_thing = self.c.get_contract('foreign_thing')
def tearDown(self):
self.c.flush()
def test_H_values_return(self):
output = self.foreign_thing.read_H_hello()
self.assertEqual(output, 'there')
output = self.foreign_thing.read_H_something()
self.assertEqual(output, 'else')
def test_cant_modify_H(self):
with self.assertRaises(ReferenceError):
self.foreign_thing.set_H(k='hello', v='not_there')
def test_cant_add_H(self):
with self.assertRaises(ReferenceError):
self.foreign_thing.set_H(k='asdf', v='123')
def test_cant_set_V(self):
with self.assertRaises(ReferenceError):
self.foreign_thing.set_V(v=123)
def test_V_returns(self):
output = self.foreign_thing.read_V()
self.assertEqual(output, 'hi')
def test_single_too_many_writes_fails(self):
tmwc = self.c.get_contract('too_many_writes')
self.c.executor.metering = True
self.c.set_var(contract='currency', variable='balances', arguments=['stu'], value=1000000)
with self.assertRaises(AssertionError):
tmwc.single()
self.c.executor.metering = False
def test_multiple_too_many_writes_fails(self):
tmwc = self.c.get_contract('too_many_writes')
self.c.executor.metering = True
self.c.set_var(contract='currency', variable='balances', arguments=['stu'], value=1000000)
with self.assertRaises(AssertionError):
tmwc.multiple()
self.c.executor.metering = False
def test_failed_once_doesnt_affect_others(self):
tmwc = self.c.get_contract('too_many_writes')
self.c.executor.metering = True
self.c.set_var(contract='currency', variable='balances', arguments=['stu'], value=1000000)
with self.assertRaises(AssertionError):
tmwc.multiple()
tmwc.not_enough()
self.c.executor.metering = False
def test_memory_overload(self):
tmwc = self.c.get_contract('too_many_writes')
self.c.executor.metering = True
self.c.set_var(contract='currency', variable='balances', arguments=['stu'], value=1000000)
with self.assertRaises(AssertionError):
tmwc.run()
self.c.executor.metering = False
def test_memory_overload2(self):
tmwc = self.c.get_contract('too_many_writes')
self.c.executor.metering = True
self.c.set_var(contract='currency', variable='balances', arguments=['stu'], value=1000000)
with self.assertRaises(AssertionError):
tmwc.run2()
self.c.executor.metering = False
def test_memory_exploit(self):
self.c.executor.metering = True
self.c.set_var(contract='currency', variable='balances', arguments=['stu'], value=1000000)
with self.assertRaises(AssertionError):
self.c.submit(exploit)
self.c.executor.metering = False