def return_contract(): # pragma: no cover
client = ContractingClient()
return client.closure_to_code_string(dex)[0] # Returns code
def setUp(self):
self.client = ContractingClient()
self.client.flush()
self.client.submit(election_house, name='election_house2')
self.election_house = self.client.get_contract(name='election_house2')
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 TestAuthenticator(TestCase):
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.w = Wallet()
masternodes = [
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
]
delegates = [
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
Wallet().verifying_key().hex(),
]
self.c = ContractingClient()
self.c.flush()
sync.submit_from_genesis_json_file(cilantro_ee.contracts.__path__[0] +
'/genesis.json',
client=self.c)
sync.submit_node_election_contracts(initial_masternodes=masternodes,
boot_mns=1,
initial_delegates=delegates,
boot_dels=1,
client=self.c)
self.s = SocketAuthenticator(ctx=self.ctx)
def tearDown(self):
self.ctx.destroy()
self.c.flush()
def test_double_init(self):
w = Wallet()
with self.assertRaises(Exception):
b = SocketAuthenticator(ctx=self.ctx)
def test_add_verifying_key_as_bytes(self):
sk = SigningKey.generate()
self.s.add_verifying_key(sk.verify_key.encode())
self.assertTrue(
os.path.exists(
os.path.join(self.s.cert_dir,
f'{sk.verify_key.encode().hex()}.key')))
def test_sync_certs_creates_files(self):
self.s.sync_certs()
for m in self.s.contacts.masternodes:
self.assertTrue(
os.path.exists(os.path.join(self.s.cert_dir, f'{m}.key')))
for d in self.s.contacts.delegates:
self.assertTrue(
os.path.exists(os.path.join(self.s.cert_dir, f'{d}.key')))
def test_add_governance_sockets_all_creates_files(self):
fake_mns = [
Wallet().verifying_key(),
Wallet().verifying_key(),
Wallet().verifying_key()
]
fake_od_m = Wallet().verifying_key()
fake_dels = [Wallet().verifying_key(), Wallet().verifying_key()]
fake_od_d = Wallet().verifying_key()
self.s.add_governance_sockets(masternode_list=fake_mns,
on_deck_masternode=fake_od_m,
delegate_list=fake_dels,
on_deck_delegate=fake_od_d)
for m in fake_mns:
self.assertTrue(
os.path.exists(os.path.join(self.s.cert_dir,
f'{m.hex()}.key')))
for d in fake_dels:
self.assertTrue(
os.path.exists(os.path.join(self.s.cert_dir,
f'{d.hex()}.key')))
self.assertTrue(
os.path.exists(
os.path.join(self.s.cert_dir, f'{fake_od_m.hex()}.key')))
self.assertTrue(
os.path.exists(
os.path.join(self.s.cert_dir, f'{fake_od_d.hex()}.key')))
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
ContractingClient().flush()
asyncio.set_event_loop(self.loop)
def __init__(self,
socket_base,
ctx: zmq.asyncio.Context,
wallet,
constitution: dict,
bootnodes={},
blocks=storage.BlockStorage(),
driver=ContractDriver(),
debug=True,
store=False,
seed=None,
bypass_catchup=False,
node_type=None,
genesis_path=lamden.contracts.__path__[0],
reward_manager=rewards.RewardManager(),
nonces=storage.NonceStorage()):
self.driver = driver
self.nonces = nonces
self.store = store
self.seed = seed
self.blocks = blocks
self.event_writer = EventWriter()
self.log = get_logger('Base')
self.log.propagate = debug
self.socket_base = socket_base
self.wallet = wallet
self.ctx = ctx
self.genesis_path = genesis_path
self.client = ContractingClient(driver=self.driver,
submission_filename=genesis_path +
'/submission.s.py')
self.bootnodes = bootnodes
self.constitution = constitution
self.seed_genesis_contracts()
self.socket_authenticator = authentication.SocketAuthenticator(
bootnodes=self.bootnodes, ctx=self.ctx, client=self.client)
self.upgrade_manager = upgrade.UpgradeManager(client=self.client,
wallet=self.wallet,
node_type=node_type)
self.router = router.Router(socket_id=socket_base,
ctx=self.ctx,
wallet=wallet,
secure=True)
self.network = network.Network(wallet=wallet,
ip_string=socket_base,
ctx=self.ctx,
router=self.router)
self.new_block_processor = NewBlock(driver=self.driver)
self.router.add_service(
NEW_BLOCK_SERVICE,
self.new_block_processor) # Add this after catch up?
self.running = False
self.upgrade = False
self.reward_manager = reward_manager
self.current_height = storage.get_latest_block_height(self.driver)
self.current_hash = storage.get_latest_block_hash(self.driver)
self.bypass_catchup = bypass_catchup
from contracting.client import ContractingClient
client = ContractingClient()
# Make sure mongdob is running
# docker run -d -p 27017–27019:27017–27019 — name mongodb mongo:4.2
def hello_world():
@export
def hello():
return 'World!'
# @export must be typesafe
@export
def add(a: int, b: int):
return private_add(a, b)
# @private functions do not require to be typesafe
def private_add(a, b):
return a + b
def transaction_is_valid(transaction,
expected_processor,
client: ContractingClient,
nonces: storage.NonceStorage,
strict=True,
tx_per_block=15,
timeout=5):
# Check basic formatting so we can access via __getitem__ notation without errors
if not check_format(transaction, rules.TRANSACTION_RULES):
return TransactionFormattingError
transaction_is_not_expired(transaction, timeout)
# Put in to variables for visual ease
processor = transaction['payload']['processor']
sender = transaction['payload']['sender']
# Checks if correct processor and if signature is valid
check_tx_formatting(transaction, expected_processor)
# Gets the expected nonces
nonce, pending_nonce = get_nonces(sender, processor, nonces)
# Get the provided nonce
tx_nonce = transaction['payload']['nonce']
# Check to see if the provided nonce is valid to what we expect and
# if there are less than the max pending txs in the block
get_new_pending_nonce(tx_nonce,
nonce,
pending_nonce,
strict=strict,
tx_per_block=tx_per_block)
# Get the senders balance and the current stamp rate
balance = client.get_var(contract='currency',
variable='balances',
arguments=[sender],
mark=False)
stamp_rate = client.get_var(contract='stamp_cost',
variable='S',
arguments=['value'],
mark=False)
contract = transaction['payload']['contract']
func = transaction['payload']['function']
stamps_supplied = transaction['payload']['stamps_supplied']
if stamps_supplied is None:
stamps_supplied = 0
if stamp_rate is None:
stamp_rate = 0
if balance is None:
balance = 0
# Get how much they are sending
amount = transaction['payload']['kwargs'].get('amount')
if amount is None:
amount = 0
# Check if they have enough stamps for the operation
has_enough_stamps(balance,
stamp_rate,
stamps_supplied,
contract=contract,
function=func,
amount=amount)
# Check if contract name is valid
name = transaction['payload']['kwargs'].get('name')
contract_name_is_valid(contract, func, name)
class TestDynamicImports(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()
# submit erc20 clone
with open('./test_contracts/stubucks.s.py') as f:
code = f.read()
self.c.submit(code, name='stubucks')
with open('./test_contracts/tejastokens.s.py') as f:
code = f.read()
self.c.submit(code, name='tejastokens')
with open('./test_contracts/bastardcoin.s.py') as f:
code = f.read()
self.c.submit(code, name='bastardcoin')
with open('./test_contracts/dynamic_importing.s.py') as f:
code = f.read()
self.c.submit(code, name='dynamic_importing')
self.stubucks = self.c.get_contract('stubucks')
self.tejastokens = self.c.get_contract('tejastokens')
self.bastardcoin = self.c.get_contract('bastardcoin')
self.dynamic_importing = self.c.get_contract('dynamic_importing')
def tearDown(self):
self.c.raw_driver.flush()
def test_successful_submission(self):
self.assertEqual(self.stubucks.balance_of(account='stu'), 123)
self.assertEqual(self.stubucks.balance_of(account='colin'), 321)
self.assertEqual(self.tejastokens.balance_of(account='stu'), 321)
self.assertEqual(self.tejastokens.balance_of(account='colin'), 123)
self.assertEqual(self.bastardcoin.balance_of(account='stu'), 999)
self.assertEqual(self.bastardcoin.balance_of(account='colin'), 555)
def test_get_stubuck_balances(self):
stu = self.dynamic_importing.balance_for_token(tok='stubucks',
account='stu')
colin = self.dynamic_importing.balance_for_token(tok='stubucks',
account='colin')
self.assertEqual(stu, 123)
self.assertEqual(colin, 321)
def test_get_tejastokens_balances(self):
stu = self.dynamic_importing.balance_for_token(tok='tejastokens',
account='stu')
colin = self.dynamic_importing.balance_for_token(tok='tejastokens',
account='colin')
self.assertEqual(stu, 321)
self.assertEqual(colin, 123)
def test_get_bastardcoin_balances(self):
stu = self.dynamic_importing.balance_for_token(tok='bastardcoin',
account='stu')
colin = self.dynamic_importing.balance_for_token(tok='bastardcoin',
account='colin')
self.assertEqual(stu, 999)
self.assertEqual(colin, 555)
def test_is_erc20(self):
self.assertTrue(
self.dynamic_importing.is_erc20_compatible(tok='stubucks'))
self.assertTrue(
self.dynamic_importing.is_erc20_compatible(tok='tejastokens'))
self.assertFalse(
self.dynamic_importing.is_erc20_compatible(tok='bastardcoin'))
def test_get_balances_erc20_enforced_stubucks(self):
stu = self.dynamic_importing.only_erc20(tok='stubucks', account='stu')
colin = self.dynamic_importing.only_erc20(tok='stubucks',
account='colin')
self.assertEqual(stu, 123)
self.assertEqual(colin, 321)
def test_get_balances_erc20_enforced_tejastokens(self):
stu = self.dynamic_importing.only_erc20(tok='tejastokens',
account='stu')
colin = self.dynamic_importing.only_erc20(tok='tejastokens',
account='colin')
self.assertEqual(stu, 321)
self.assertEqual(colin, 123)
def test_erc20_enforced_fails_for_bastardcoin(self):
with self.assertRaises(AssertionError):
stu = self.dynamic_importing.only_erc20(tok='bastardcoin',
account='stu')
def test_owner_of_returns_default(self):
with open('./test_contracts/owner_stuff.s.py') as f:
code = f.read()
self.c.submit(code, name='owner_stuff', owner='poo')
owner_stuff = self.c.get_contract('owner_stuff')
self.assertIsNone(owner_stuff.get_owner(s='stubucks', signer='poo'))
self.assertEqual(owner_stuff.get_owner(s='owner_stuff', signer='poo'),
'poo')
def test_ctx_owner_works(self):
with open('./test_contracts/owner_stuff.s.py') as f:
code = f.read()
self.c.submit(code, name='owner_stuff', owner='poot')
owner_stuff = self.c.get_contract('owner_stuff')
self.assertEqual(owner_stuff.owner_of_this(signer='poot'), 'poot')
def test_incorrect_owner_prevents_function_call(self):
with open('./test_contracts/owner_stuff.s.py') as f:
code = f.read()
self.c.submit(code, name='owner_stuff', owner='poot')
owner_stuff = self.c.get_contract('owner_stuff')
with self.assertRaises(Exception):
owner_stuff.owner_of_this()
def test_delegate_call_with_owner_works(self):
with open('./test_contracts/parent_test.s.py') as f:
code = f.read()
self.c.submit(code, name='parent_test')
with open('./test_contracts/child_test.s.py') as f:
code = f.read()
self.c.submit(code, name='child_test', owner='parent_test')
parent_test = self.c.get_contract('parent_test')
val = parent_test.get_val_from_child(s='child_test')
self.assertEqual(val, 'good')
def test_delegate_with_wrong_owner_does_not_work(self):
with open('./test_contracts/parent_test.s.py') as f:
code = f.read()
self.c.submit(code, name='parent_test')
with open('./test_contracts/child_test.s.py') as f:
code = f.read()
self.c.submit(code, name='child_test', owner='blorg')
parent_test = self.c.get_contract('parent_test')
with self.assertRaises(Exception) as e:
parent_test.get_val_from_child(s='child_test')
class TestDeveloperSubmission(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()
def test_submit_sets_developer(self):
self.c.submit(test)
dev = self.c.get_var('test', '__developer__')
self.assertEqual(dev, 'stu')
def test_change_developer_if_developer_works(self):
self.c.submit(test)
submission = self.c.get_contract('submission')
submission.change_developer(contract='test', new_developer='not_stu')
dev = self.c.get_var('test', '__developer__')
self.assertEqual(dev, 'not_stu')
def test_change_developer_prevents_new_change(self):
self.c.submit(test)
submission = self.c.get_contract('submission')
submission.change_developer(contract='test', new_developer='not_stu')
with self.assertRaises(AssertionError):
submission.change_developer(contract='test', new_developer='woohoo')
def test_cannot_import_submission(self):
self.c.submit(import_submission)
imp_con = self.c.get_contract('import_submission')
with self.assertRaises(AssertionError):
imp_con.haha()
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
class TestSenecaClientReplacesExecutor(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')
# submit erc20 clone
with open('./test_contracts/erc20_clone.s.py') as f:
code = f.read()
self.c.submit(code, name='erc20_clone')
with open('./test_contracts/atomic_swaps.s.py') as f:
code = f.read()
self.c.submit(code, name='atomic_swaps')
self.erc20_clone = self.c.get_contract('erc20_clone')
self.atomic_swaps = self.c.get_contract('atomic_swaps')
def tearDown(self):
self.c.raw_driver.flush()
def test_initiate_not_enough_approved(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
with self.assertRaises(AssertionError):
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5000000)
def test_initiate_transfers_coins_correctly(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
atomic_swaps = self.erc20_clone.balance_of(account='atomic_swaps')
stu_bal = self.erc20_clone.balance_of(account='stu')
stu_as = self.erc20_clone.allowance(owner='stu',
spender='atomic_swaps')
self.assertEqual(atomic_swaps, 5)
self.assertEqual(stu_bal, 999995)
self.assertEqual(stu_as, 999995)
def test_initiate_writes_to_correct_key_and_properly(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
key = 'atomic_swaps.swaps:raghu:eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514'
expiration, amount = self.c.raw_driver.get(key)
self.assertEqual(expiration, Datetime(2020, 1, 1))
self.assertEqual(amount, 5)
def test_redeem_on_wrong_secret_fails(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
with self.assertRaises(AssertionError):
self.atomic_swaps.redeem(signer='raghu', secret='00')
def test_redeem_on_wrong_sender_fails(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
with self.assertRaises(AssertionError):
self.atomic_swaps.redeem(secret='842b65a7d48e3a3c3f0e9d37eaced0b2')
def test_past_expiration_fails(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
environment = {'now': Datetime(2021, 1, 1)}
with self.assertRaises(AssertionError):
self.atomic_swaps.redeem(secret='842b65a7d48e3a3c3f0e9d37eaced0b2',
signer='raghu',
environment=environment)
def test_successful_redeem_transfers_coins_correctly(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
environment = {'now': Datetime(2019, 1, 1)}
self.atomic_swaps.redeem(secret='842b65a7d48e3a3c3f0e9d37eaced0b2',
signer='raghu',
environment=environment)
atomic_swaps = self.erc20_clone.balance_of(account='atomic_swaps')
raghu = self.erc20_clone.balance_of(account='raghu')
self.assertEqual(raghu, 5)
self.assertEqual(atomic_swaps, 0)
def test_successful_redeem_deletes_entry(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
environment = {'now': Datetime(2019, 1, 1)}
self.atomic_swaps.redeem(secret='842b65a7d48e3a3c3f0e9d37eaced0b2',
signer='raghu',
environment=environment)
key = 'atomic_swaps.swaps:raghu:eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514'
v = self.c.raw_driver.get(key)
self.assertEqual(v, None)
def test_refund_works(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
environment = {'now': Datetime(2021, 1, 1)}
self.atomic_swaps.refund(participant='raghu',
secret='842b65a7d48e3a3c3f0e9d37eaced0b2',
environment=environment)
atomic_swaps = self.erc20_clone.balance_of(account='atomic_swaps')
stu = self.erc20_clone.balance_of(account='stu')
self.assertEqual(stu, 1000000)
self.assertEqual(atomic_swaps, 0)
def test_refund_too_early_fails(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
environment = {'now': Datetime(2019, 1, 1)}
with self.assertRaises(AssertionError):
self.atomic_swaps.refund(participant='raghu',
secret='842b65a7d48e3a3c3f0e9d37eaced0b2',
environment=environment)
def test_refund_participant_is_signer_fails(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
environment = {'now': Datetime(2021, 1, 1)}
with self.assertRaises(AssertionError):
self.atomic_swaps.refund(participant='raghu',
secret='842b65a7d48e3a3c3f0e9d37eaced0b2',
environment=environment,
signer='raghu')
def test_refund_fails_with_wrong_secret(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
environment = {'now': Datetime(2021, 1, 1)}
with self.assertRaises(AssertionError):
self.atomic_swaps.refund(
participant='raghu',
secret='00',
environment=environment,
)
def test_refund_resets_swaps(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
environment = {'now': Datetime(2021, 1, 1)}
self.atomic_swaps.refund(participant='raghu',
secret='842b65a7d48e3a3c3f0e9d37eaced0b2',
environment=environment)
key = 'atomic_swaps.swaps:raghu:eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514'
v = self.c.raw_driver.get(key)
self.assertEqual(v, None)
class TokenTests(unittest.TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
with open('dai.py') as file:
code = file.read()
self.client.submit(code,
name='dai_token',
constructor_args={'owner': 'me'})
self.dai = self.client.get_contract('dai_token')
self.dai.mint(amount=1000000, signer='me')
def tearDown(self):
self.client.flush()
def test_transfer_negative(self):
try:
self.dai.transfer(amount=-1, to='wallet2', signer='me')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_transfer_excess(self):
try:
self.dai.transfer(amount=1000001, to='wallet2', signer='me')
raise
except AssertionError as message:
assert 'enough' in str(message)
def test_transfer_normal(self):
self.dai.transfer(amount=42, to='wallet2', signer='me')
self.assertAlmostEqual(self.dai.balance_of(account='me'), 1000000 - 42)
self.assertAlmostEqual(self.dai.balance_of(account='wallet2'), 42)
def test_balance(self):
self.assertAlmostEqual(self.dai.balance_of(account='me'), 1000000)
self.assertAlmostEqual(self.dai.balance_of(account='wallet2'), 0)
def test_accounts_negative(self):
try:
self.dai.approve(amount=-1, to='account1', signer='me')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_accounts_normal(self):
self.dai.approve(amount=42, to='account1', signer='me')
self.assertAlmostEqual(
self.dai.allowance(owner='me', spender='account1', signer='me'),
42)
def test_transfer_from_negative(self):
self.dai.approve(amount=42, to='account1', signer='me')
try:
self.dai.transfer_from(amount=-1,
to='wallet2',
main_account='me',
signer='account1')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_transfer_from_excess(self):
self.dai.approve(amount=42, to='account1', signer='me')
try:
self.dai.transfer_from(amount=1000001,
to='wallet2',
main_account='me',
signer='account1')
raise
except AssertionError as message:
assert 'enough' in str(message)
def test_transfer_from_approved(self):
self.dai.approve(amount=42, to='account1', signer='me')
try:
self.dai.transfer_from(amount=1000000,
to='wallet2',
main_account='me',
signer='account1')
raise
except AssertionError as message:
assert 'approved' in str(message)
def test_transfer_from_normal(self):
self.dai.approve(amount=42, to='account1', signer='me')
self.dai.transfer_from(amount=42,
to='wallet2',
main_account='me',
signer='account1')
self.assertAlmostEqual(
self.dai.allowance(owner='me', spender='account1', signer='me'), 0)
self.assertAlmostEqual(self.dai.balance_of(account='me'), 1000000 - 42)
self.assertAlmostEqual(self.dai.balance_of(account='wallet2'), 42)
def test_burn_negative(self):
try:
self.dai.burn(amount=-1, signer='me')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_burn_excess(self):
try:
self.dai.burn(amount=1000001, signer='me')
raise
except AssertionError as message:
assert 'enough' in str(message)
def test_burn_normal(self):
old_supply = self.dai.get_total_supply()
self.dai.burn(amount=42, signer='me')
self.assertAlmostEqual(self.dai.get_total_supply(), old_supply - 42)
def test_mint_negative(self):
try:
self.dai.mint(amount=-1, signer='me')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_mint_unauthorised(self):
try:
self.dai.mint(amount=42, signer='wallet1')
raise
except AssertionError as message:
assert 'operator' in str(message)
def test_mint_normal(self):
old_supply = self.dai.get_total_supply()
self.dai.mint(amount=42, signer='me')
self.assertAlmostEqual(self.dai.get_total_supply(), old_supply + 42)
def test_metadata_unauthorised(self):
try:
self.dai.change_metadata(key='testing',
value='testing',
signer='me')
raise
except AssertionError as message:
assert 'operator' in str(message)
def test_metadata_normal(self):
self.dai.change_metadata(key='testing', value='testing')
assert self.dai.metadata['testing'] == 'testing'
self.dai.change_metadata(key='testing', value='again')
assert self.dai.metadata['testing'] == 'again'
def test_change_owner_unauthorised(self):
try:
self.dai.change_owner(new_owner='wallet2', signer='wallet2')
raise
except AssertionError as message:
assert 'operator' in str(message)
def test_change_owner_normal(self):
self.dai.change_owner(new_owner='wallet2', signer='me')
try:
self.dai.change_owner(new_owner='me', signer='me')
raise
except AssertionError as message:
assert 'operator' in str(message)
class StakingTests(unittest.TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
with open('tad.py') as file:
tad = file.read()
with open('vault.py') as file:
vault = file.read()
with open('test_currency.py') as file:
currency = file.read()
with open('oracle.py') as file:
oracle = file.read()
with open('stake.py') as file:
staking = file.read()
self.client.submit(tad,
name='tad_contract',
constructor_args={'owner': 'vault_contract'})
self.client.submit(vault, name='vault_contract')
self.client.submit(currency, name='currency')
self.client.submit(oracle, name='oracle')
self.client.submit(staking, name='staking')
self.tad = self.client.get_contract('tad_contract')
self.vault = self.client.get_contract('vault_contract')
self.currency = self.client.get_contract('currency')
self.oracle = self.client.get_contract('oracle')
self.staking = self.client.get_contract('staking')
self.tad.mint(amount=2000000, signer='vault_contract')
self.tad.transfer(amount=2000000,
to='testing_user',
signer='vault_contract')
self.oracle.set_price(number=0, new_price=1.0) # Probably not needed
self.vault.change_any_state(key=('mint', 'DSR', 'owner'),
new_value='staking')
def tearDown(self):
self.client.flush()
def test_metadata_unauthorised(self):
with self.assertRaisesRegex(AssertionError, 'operator'):
self.staking.change_metadata(key='testing',
value='testing',
signer='me')
def test_metadata_normal(self):
self.staking.change_metadata(key='testing', value='testing')
assert self.staking.metadata['testing'] == 'testing'
self.staking.change_metadata(key='testing', value='again')
assert self.staking.metadata['testing'] == 'again'
def test_change_owner_unauthorised(self):
with self.assertRaisesRegex(AssertionError, 'operator'):
self.staking.change_owner(new_owner='wallet2', signer='wallet2')
def test_change_owner_normal(self):
self.staking.change_owner(new_owner='wallet2')
with self.assertRaisesRegex(AssertionError, 'operator'):
self.staking.change_owner(new_owner='me')
self.staking.change_owner(new_owner='me', signer='wallet2')
def test_change_rate_unauthorised(self):
with self.assertRaisesRegex(AssertionError, 'operator'):
self.staking.change_rate(new_rate=0.1, signer='wallet2')
def test_change_rate_negative(self):
with self.assertRaisesRegex(AssertionError, 'negative'):
self.staking.change_rate(new_rate=-0.1)
def test_change_rate_normal(self):
current_price = self.staking.get_price()
self.staking.change_rate(new_rate=0.1)
self.assertAlmostEqual(0.1, self.staking.rate['rate'])
self.assertAlmostEqual(self.staking.rate['start_price'], current_price)
def test_stake_negative(self):
with self.assertRaisesRegex(AssertionError, 'positive'):
self.staking.stake(amount=-1)
def test_stake_insufficient(self):
with self.assertRaisesRegex(AssertionError, 'enough'):
self.staking.stake(amount=1000001)
def test_stake_normal(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
def test_stake_takes_money(self):
self.assertAlmostEqual(self.tad.balance_of(account='testing_user'),
2000000)
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.assertAlmostEqual(self.tad.balance_of(account='testing_user'),
1000000)
def test_stake_updates_balance(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.assertAlmostEqual(self.staking.balances['testing_user'], 1000000)
def test_stake_sets_total_minted(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.assertAlmostEqual(self.staking.total_minted.get(), 2000000)
def test_withdraw_stake_negative(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
with self.assertRaisesRegex(AssertionError, 'positive'):
self.staking.withdraw_stake(amount=-1, signer='testing_user')
def test_withdraw_stake_insufficient(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
with self.assertRaisesRegex(AssertionError, 'enough'):
self.staking.withdraw_stake(amount=1000001, signer='testing_user')
def test_stake_records_balance(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.assertAlmostEqual(self.staking.balances['testing_user'], 1000000)
self.assertEqual(self.staking.balances['wallet2'], None)
def test_withdraw_stake_normal(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.withdraw_stake(amount=1000000, signer='testing_user')
def test_withdraw_stake_returns_money(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.withdraw_stake(amount=1000000, signer='testing_user')
self.assertAlmostEqual(self.tad.balance_of(account='testing_user'),
2000000)
def test_withdraw_stake_returns_rewards(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
env = {'now': Datetime(year=2022, month=12, day=31)} # mocks the date
self.staking.withdraw_stake(amount=1000000,
signer='testing_user',
environment=env)
assert self.tad.balance_of(account='testing_user') > 2000000
def test_transfer_negative(self):
with self.assertRaisesRegex(AssertionError, 'negative'):
self.staking.transfer(amount=-1,
to='wallet2',
signer='testing_user')
def test_transfer_excess(self):
with self.assertRaisesRegex(AssertionError, 'enough'):
self.staking.transfer(amount=1000001,
to='wallet2',
signer='testing_user')
def test_transfer_normal(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.transfer(amount=42, to='wallet2', signer='testing_user')
self.assertAlmostEqual(self.staking.balance_of(account='testing_user'),
1000000 - 42)
self.assertAlmostEqual(self.staking.balance_of(account='wallet2'), 42)
def test_accounts_negative(self):
with self.assertRaisesRegex(AssertionError, 'negative'):
self.staking.approve(amount=-1,
to='account1',
signer='testing_user')
def test_accounts_excess(self):
with self.assertRaisesRegex(AssertionError, 'exceeds'):
self.staking.approve(amount=1000001,
to='account1',
signer='testing_user')
def test_accounts_updates_internal_balance(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.approve(amount=42, to='account1', signer='testing_user')
self.assertAlmostEqual(
self.staking.balances['testing_user', 'account1'], 42)
def test_accounts_normal(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.approve(amount=42, to='account1', signer='testing_user')
self.assertAlmostEqual(
self.staking.allowance(owner='testing_user',
spender='account1',
signer='me'), 42)
def test_transfer_from_negative(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.approve(amount=42, to='account1', signer='testing_user')
with self.assertRaisesRegex(AssertionError, 'negative'):
self.staking.transfer_from(amount=-1,
to='wallet2',
main_account='testing_user',
signer='account1')
def test_transfer_from_excess(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.approve(amount=42, to='account1', signer='testing_user')
with self.assertRaisesRegex(AssertionError, 'enough'):
self.staking.transfer_from(amount=1000001,
to='wallet2',
main_account='testing_user',
signer='account1')
def test_transfer_from_approved(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.approve(amount=42, to='account1', signer='testing_user')
with self.assertRaisesRegex(AssertionError, 'approved'):
self.staking.transfer_from(amount=1000000,
to='wallet2',
main_account='testing_user',
signer='account1')
def test_transfer_from_normal_sends(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.approve(amount=42, to='account1', signer='testing_user')
self.staking.transfer_from(amount=42,
to='wallet2',
main_account='testing_user',
signer='account1')
self.assertAlmostEqual(
self.staking.allowance(owner='testing_user',
spender='account1',
signer='me'), 0)
self.assertAlmostEqual(self.staking.balance_of(account='testing_user'),
1000000 - 42)
def test_transfer_from_normal_receives(self):
self.tad.approve(to='staking', amount=1000000, signer='testing_user')
self.staking.stake(amount=1000000, signer='testing_user')
self.staking.approve(amount=42, to='account1', signer='testing_user')
self.staking.transfer_from(amount=42,
to='wallet2',
main_account='testing_user',
signer='account1')
self.assertAlmostEqual(self.staking.balance_of(account='wallet2'), 42)
def test_get_price(self):
current_rate = self.staking.get_price()
env = {'now': Datetime(year=2022, month=12, day=31)} # mocks the date
with self.assertRaisesRegex(AssertionError, '!='):
self.assertEqual(current_rate,
self.staking.get_price(environment=env))
def test_timestamp_is_correct(self):
assert abs(datetime.datetime.utcnow().timestamp() -
self.vault.get_timestamp()) % 14400 < 120
#tests/test_contract.py
import unittest
from contracting.client import ContractingClient
client = ContractingClient()
with open('../my_token.py') as f:
code = f.read()
client.submit(code, name='my_token')
class MyTestCase(unittest.TestCase):
def test_supply(self):
# Get contract reference
my_token = client.get_contract('my_token')
# Assert token balance for 'me'
self.assertEqual(my_token.quick_read('S', 'me'), 50)
def test_transfer(self):
# set transaction sender
client.signer = 'me'
# Get contract reference
my_token = client.get_contract('my_token')
# Call transfer method
my_token.transfer(amount=10, receiver='you')
# Assert token balance for 'me'
self.assertEqual(my_token.quick_read('S', 'me'), 40)
# Assert token balance for 'you'
self.assertEqual(my_token.quick_read('S', 'you'), 10)
def test_transfer_neg_insufficient_funds(self):
import unittest
from contracting.client import ContractingClient
# make sure mongoDB is running with: sudo systemctl start mongod
client = ContractingClient()
filelocation = '/home/covenant/Documents/Lamden/Automated Pay Distribution/apd_v01.py' #main_file.py'
filename = 'apd' #'main_file'
with open(filelocation) as f:
code = f.read()
client.submit(code,
name=filename,
constructor_args={
'vk': 'me',
'amount': 50
})
class MyTestCase(unittest.TestCase):
def test_supply(self):
contract = client.get_contract(filename)
supply = 50
#print(contract.quick_read('State', 'me'), supply)
self.assertEqual(contract.quick_read('State', 'me'), supply)
def test_transfer(self):
client.signer = 'me'
contract = client.get_contract(filename)
supply = 50
class Node:
def __init__(self,
socket_base,
ctx: zmq.asyncio.Context,
wallet,
constitution: dict,
bootnodes={},
blocks=storage.BlockStorage(),
driver=ContractDriver(),
debug=True,
store=False,
seed=None,
bypass_catchup=False,
node_type=None,
genesis_path=lamden.contracts.__path__[0],
reward_manager=rewards.RewardManager(),
nonces=storage.NonceStorage()):
self.driver = driver
self.nonces = nonces
self.store = store
self.seed = seed
self.blocks = blocks
self.event_writer = EventWriter()
self.log = get_logger('Base')
self.log.propagate = debug
self.socket_base = socket_base
self.wallet = wallet
self.ctx = ctx
self.genesis_path = genesis_path
self.client = ContractingClient(driver=self.driver,
submission_filename=genesis_path +
'/submission.s.py')
self.bootnodes = bootnodes
self.constitution = constitution
self.seed_genesis_contracts()
self.socket_authenticator = authentication.SocketAuthenticator(
bootnodes=self.bootnodes, ctx=self.ctx, client=self.client)
self.upgrade_manager = upgrade.UpgradeManager(client=self.client,
wallet=self.wallet,
node_type=node_type)
self.router = router.Router(socket_id=socket_base,
ctx=self.ctx,
wallet=wallet,
secure=True)
self.network = network.Network(wallet=wallet,
ip_string=socket_base,
ctx=self.ctx,
router=self.router)
self.new_block_processor = NewBlock(driver=self.driver)
self.router.add_service(
NEW_BLOCK_SERVICE,
self.new_block_processor) # Add this after catch up?
self.running = False
self.upgrade = False
self.reward_manager = reward_manager
self.current_height = storage.get_latest_block_height(self.driver)
self.current_hash = storage.get_latest_block_hash(self.driver)
self.bypass_catchup = bypass_catchup
def seed_genesis_contracts(self):
self.log.info('Setting up genesis contracts.')
sync.setup_genesis_contracts(
initial_masternodes=self.constitution['masternodes'],
initial_delegates=self.constitution['delegates'],
client=self.client,
filename=self.genesis_path + '/genesis.json',
root=self.genesis_path)
async def catchup(self, mn_seed, mn_vk):
# Get the current latest block stored and the latest block of the network
self.log.info('Running catchup.')
current = self.current_height
latest = await get_latest_block_height(ip=mn_seed,
vk=mn_vk,
wallet=self.wallet,
ctx=self.ctx)
self.log.info(
f'Current block: {current}, Latest available block: {latest}')
if latest == 0 or latest is None or type(latest) == dict:
self.log.info('No need to catchup. Proceeding.')
return
# Increment current by one. Don't count the genesis block.
if current == 0:
current = 1
# Find the missing blocks process them
for i in range(current, latest + 1):
block = None
while block is None:
block = await get_block(block_num=i,
ip=mn_seed,
vk=mn_vk,
wallet=self.wallet,
ctx=self.ctx)
self.process_new_block(block)
# Process any blocks that were made while we were catching up
while len(self.new_block_processor.q) > 0:
block = self.new_block_processor.q.pop(0)
self.process_new_block(block)
def should_process(self, block):
try:
self.log.info(f'Processing block #{block.get("number")}')
except:
self.log.error('Malformed block :(')
return False
# Test if block failed immediately
if block == {'response': 'ok'}:
return False
if block['hash'] == 'f' * 64:
self.log.error('Failed Block! Not storing.')
return False
# Get current metastate
# if len(block['subblocks']) < 1:
# return False
# Test if block contains the same metastate
# if block['number'] != self.current_height + 1:
# self.log.info(f'Block #{block["number"]} != {self.current_height + 1}. '
# f'Node has probably already processed this block. Continuing.')
# return False
# if block['previous'] != self.current_hash:
# self.log.error('Previous block hash != Current hash. Cryptographically invalid. Not storing.')
# return False
# If so, use metastate and subblocks to create the 'expected' block
# expected_block = canonical.block_from_subblocks(
# subblocks=block['subblocks'],
# previous_hash=self.current_hash,
# block_num=self.current_height + 1
# )
# Return if the block contains the expected information
# good = block == expected_block
# if good:
# self.log.info(f'Block #{block["number"]} passed all checks. Store.')
# else:
# self.log.error(f'Block #{block["number"]} has an encoding problem. Do not store.')
#
# return good
return True
def update_state(self, block):
self.driver.clear_pending_state()
# Check if the block is valid
if self.should_process(block):
self.log.info('Storing new block.')
# Commit the state changes and nonces to the database
storage.update_state_with_block(block=block,
driver=self.driver,
nonces=self.nonces)
self.log.info('Issuing rewards.')
# Calculate and issue the rewards for the governance nodes
self.reward_manager.issue_rewards(block=block, client=self.client)
#self.nonces.flush_pending()
self.log.info('Updating metadata.')
self.current_height = storage.get_latest_block_height(self.driver)
self.current_hash = storage.get_latest_block_hash(self.driver)
self.new_block_processor.clean(self.current_height)
def process_new_block(self, block):
# Update the state and refresh the sockets so new nodes can join
self.update_state(block)
self.socket_authenticator.refresh_governance_sockets()
# Store the block if it's a masternode
if self.store:
encoded_block = encode(block)
encoded_block = json.loads(encoded_block)
self.blocks.store_block(encoded_block)
# create Event File
self.event_writer.write_event(
Event(topics=[NEW_BLOCK_EVENT], data=encoded_block))
# Prepare for the next block by flushing out driver and notification state
# self.new_block_processor.clean()
# Finally, check and initiate an upgrade if one needs to be done
self.driver.commit()
self.driver.clear_pending_state()
gc.collect() # Force memory cleanup every block
self.nonces.flush_pending()
async def start(self):
asyncio.ensure_future(self.router.serve())
# Get the set of VKs we are looking for from the constitution argument
vks = self.constitution['masternodes'] + self.constitution['delegates']
for node in self.bootnodes.keys():
self.socket_authenticator.add_verifying_key(node)
self.socket_authenticator.configure()
# Use it to boot up the network
await self.network.start(bootnodes=self.bootnodes, vks=vks)
if not self.bypass_catchup:
masternode_ip = None
masternode = None
if self.seed is not None:
for k, v in self.bootnodes.items():
self.log.info(k, v)
if v == self.seed:
masternode = k
masternode_ip = v
else:
masternode = self.constitution['masternodes'][0]
masternode_ip = self.network.peers[masternode]
self.log.info(f'Masternode Seed VK: {masternode}')
# Use this IP to request any missed blocks
await self.catchup(mn_seed=masternode_ip, mn_vk=masternode)
# Refresh the sockets to accept new nodes
self.socket_authenticator.refresh_governance_sockets()
# Start running
self.running = True
def stop(self):
# Kill the router and throw the running flag to stop the loop
self.router.stop()
self.running = False
def _get_member_peers(self, contract_name):
members = self.client.get_var(contract=contract_name,
variable='S',
arguments=['members'])
member_peers = dict()
for member in members:
ip = self.network.peers.get(member)
if ip is not None:
member_peers[member] = ip
return member_peers
def get_delegate_peers(self):
return self._get_member_peers('delegates')
def get_masternode_peers(self):
return self._get_member_peers('masternodes')
def make_constitution(self):
return {
'masternodes': self.get_masternode_peers(),
'delegates': self.get_delegate_peers()
}
#tests/test_contract.py
import unittest
import base64
from contracting.client import ContractingClient
client = ContractingClient()
initial_args = {
'owner': 'stu_man',
'wait_period_hours': 0,
'max_send': 2,
'drip': 1,
'currency_symbol': 'jTAU'
}
new_args = {
'owner': 'jeff_man',
'wait_period_hours': 1,
'max_send': 100,
'drip': 100,
'currency_symbol': 'dTAU'
}
icon_svg_base64 = ""
with open('./currency.py') as f:
code = f.read()
client.submit(code, name='currency')
with open('../contracts/con_faucet.py') as f:
code = f.read()
client.submit(code, name='con_faucet', constructor_args=initial_args)
class DexPairsSpecs(TestCase):
# returns ContractingDecimal
def expand_to_token_decimals(self, amount):
return ContractingDecimal(amount / pow(10, TOKEN_DECIMALS))
# before each test, setup the conditions
def setUp(self):
self.client = ContractingClient()
self.client.flush()
self.fee_to_address = 'fee_to_address'
self.fee_to_setter_address = 'fee_to_setter_address'
self.wallet_address = 'wallet_address'
# token0
with open('../currency.py') as f:
code = f.read()
self.client.submit(code,
'tau',
constructor_args={
's_name': 'tau',
's_symbol': 'TAU',
'vk': self.wallet_address,
'vk_amount': 10000
})
# token1
with open('../basetoken.py') as f:
code = f.read()
self.client.submit(code,
name='eth',
constructor_args={
's_name': 'eth',
's_symbol': 'ETH',
'vk': self.wallet_address,
'vk_amount': 10000
})
# Dex
with open('../dex.py') as f:
code = f.read()
self.client.submit(code,
'dex',
constructor_args={
'fee_to_setter_address':
self.fee_to_setter_address
})
# Dex Pairs
# Initialize ownership to dex
with open('../dex_pairs.py') as f:
code = f.read()
self.client.submit(code,
'dex_pairs',
constructor_args={'owner_address': 'dex'})
# Change tx signer to actor1
self.change_signer(self.wallet_address)
# Create pair on Dex
self.dex.create_pair(dex_pairs='dex_pairs',
tau_contract='tau',
token_contract='eth')
def change_signer(self, name):
self.client.signer = name
self.tau = self.client.get_contract('tau')
self.eth = self.client.get_contract('eth')
self.dex = self.client.get_contract('dex')
self.dex_pairs = self.client.get_contract('dex_pairs')
def zero_address(self):
return '0'
def test_1_mint(self):
self.change_signer(self.wallet_address)
tau_amount = 1.0
eth_amount = 4.0
self.tau.transfer(amount=tau_amount, to=self.dex_pairs.name)
self.eth.transfer(amount=eth_amount, to=self.dex_pairs.name)
expected_liquidity = 2.0
token_mint_address, tau_amount, token_amount = self.dex_pairs.mint_liquidity(
dex_contract=self.dex.name,
tau_contract=self.tau.name,
token_contract=self.eth.name,
to_address=self.wallet_address)
# TODO - A4 - Asserts on Emit()
total_supply = self.dex_pairs.total_supply(
tau_contract=self.tau.name, token_contract=self.eth.name)
assert total_supply == expected_liquidity, 'Invalid Total supply'
zero_address_balance = self.dex_pairs.balance_of(
tau_contract=self.tau.name,
token_contract=self.eth.name,
account=self.zero_address())
assert zero_address_balance == self.expand_to_token_decimals(
MINIMUM_LIQUIDITY), 'Invalid minimum liquidity initialized'
wallet_address_balance = self.dex_pairs.balance_of(
tau_contract=self.tau.name,
token_contract=self.eth.name,
account=self.wallet_address)
assert wallet_address_balance == expected_liquidity - self.expand_to_token_decimals(
MINIMUM_LIQUIDITY), 'Invalid balance initialized'
assert self.tau.balance_of(
account=self.dex_pairs.name) == tau_amount, 'Invalid tau balance'
assert self.eth.balance_of(account=self.dex_pairs.name
) == eth_amount, 'Invalid ethereum balance'
tau_reserves, token_reserves = self.dex_pairs.get_pair_reserves(
tau_contract=self.tau.name, token_contract=self.eth.name)
assert tau_reserves == tau_amount, 'Invalid tau reserves'
assert token_reserves == eth_amount, 'Invalid eth reserves'
def add_liquidity(self, tau_amount, token_amount):
self.tau.transfer(amount=tau_amount, to=self.dex_pairs.name)
self.eth.transfer(amount=token_amount, to=self.dex_pairs.name)
self.dex_pairs.mint_liquidity(dex_contract=self.dex.name,
tau_contract=self.tau.name,
token_contract=self.eth.name,
to_address=self.wallet_address)
def test_2_0_swap_tests(self):
swap_test_cases = [[1, 5, 10, '1662497915624478906'],
[1, 10, 5, '453305446940074565'],
[2, 5, 10, '2851015155847869602'],
[2, 10, 5, '831248957812239453'],
[1, 10, 10, '906610893880149131'],
[1, 100, 100, '987158034397061298'],
[1, 1000, 1000, '996006981039903216']]
swap_test_cases = map(
lambda case: map(
lambda x: self.expand_to_token_decimals(int(x))
if isinstance(x, str) else ContractingDecimal(int(x)), case),
swap_test_cases)
index = 0
for test_case in swap_test_cases:
self.setUp()
swap_amount, tau_amount, token_amount, expected_output_amount = test_case
index += 1
print("Test Case [#{}] with params: [{},{},{},{}]".format(
index, swap_amount, tau_amount, token_amount,
expected_output_amount))
self.add_liquidity(tau_amount, token_amount)
self.tau.transfer(amount=swap_amount, to=self.dex_pairs.name)
# TODO - A2 - Complete UniswapV2: K exceptions
# with self.assertRaises(Exception) as context:
# self.dex_pairs.swap(
# tau_contract=self.tau.name,
# token_contract=self.eth.name,
# tau_out=0,
# token_out=expected_output_amount + 1.0, # swap more
# to_address=self.wallet_address
# )
# self.assertTrue('UniswapV2: K' in context.exception, 'UniswapV2 ')
self.dex_pairs.swap(tau_contract=self.tau.name,
token_contract=self.eth.name,
tau_out=0,
token_out=expected_output_amount,
to_address='test_results_wallet')
# Validate Reserves
tau_reserve, token_reserve = self.dex_pairs.get_pair_reserves(
tau_contract=self.tau.name, token_contract=self.eth.name)
self.assertEqual(tau_reserve, tau_amount + swap_amount)
self.assertEqual(token_reserve,
token_amount - expected_output_amount)
wallet_balance_tau = self.tau.balance_of(
account='test_results_wallet')
wallet_balance_token = self.eth.balance_of(
account='test_results_wallet')
self.assertEqual(wallet_balance_tau, 0)
self.assertEqual(wallet_balance_token, expected_output_amount)
def test_3_token0_swap(self):
self.change_signer(self.wallet_address)
tau_amount = 5
token_amount = 10
self.add_liquidity(tau_amount, token_amount)
swap_amount = 1
expected_output_amount = self.expand_to_token_decimals(
1662497915624478906)
self.tau.transfer(amount=swap_amount, to=self.dex_pairs.name)
# TODO - A4 - Asserts on Emit()
self.dex_pairs.swap(tau_contract=self.tau.name,
token_contract=self.eth.name,
tau_out=0,
token_out=expected_output_amount,
to_address='test_results_wallet')
# Validate Wallet Balances Post Swap
wallet_balance_tau = self.tau.balance_of(account='test_results_wallet')
self.assertEqual(wallet_balance_tau, 0.0)
wallet_balance_token = self.eth.balance_of(
account='test_results_wallet')
self.assertEqual(wallet_balance_token, expected_output_amount)
# Validate Reserves
tau_reserve, token_reserve = self.dex_pairs.get_pair_reserves(
tau_contract=self.tau.name, token_contract=self.eth.name)
self.assertEqual(tau_reserve, tau_amount + swap_amount)
self.assertEqual(token_reserve, token_amount - expected_output_amount)
# Validate Balances + AMM Reserves Post-Swap
pair_balance_tau = self.tau.balance_of(account=self.dex_pairs.name)
self.assertEqual(pair_balance_tau, tau_amount + swap_amount)
pair_balance_token = self.eth.balance_of(account=self.dex_pairs.name)
self.assertEqual(pair_balance_token,
token_amount - expected_output_amount)
# TODO - A4 - Token Supply Validations.
# Validate Supply @ UniswapV2Pair.specs.ts
total_supply = self.dex_pairs.total_supply(
tau_contract=self.tau.name, token_contract=self.eth.name)
def test_3_token1_swap(self):
self.change_signer(self.wallet_address)
tau_amount = 5
token_amount = 10
self.add_liquidity(tau_amount, token_amount)
swap_amount = 1
expected_output_amount = self.expand_to_token_decimals(
453305446940074565)
self.eth.transfer(amount=swap_amount, to=self.dex_pairs.name)
# TODO - A4 - Asserts on Emit()
self.dex_pairs.swap(tau_contract=self.tau.name,
token_contract=self.eth.name,
tau_out=expected_output_amount,
token_out=0,
to_address='test_results_wallet')
# Validate Wallet Balances Post Swap
wallet_balance_tau = self.tau.balance_of(account='test_results_wallet')
self.assertEqual(wallet_balance_tau, expected_output_amount)
wallet_balance_token = self.eth.balance_of(
account='test_results_wallet')
self.assertEqual(wallet_balance_token, 0.0)
# Validate Reserves
tau_reserve, token_reserve = self.dex_pairs.get_pair_reserves(
tau_contract=self.tau.name, token_contract=self.eth.name)
self.assertEqual(tau_reserve, tau_amount - expected_output_amount)
self.assertEqual(token_reserve, token_amount + swap_amount)
# Validate Balances + AMM Reserves Post-Swap
pair_balance_tau = self.tau.balance_of(account=self.dex_pairs.name)
self.assertEqual(pair_balance_tau, tau_amount - expected_output_amount)
pair_balance_token = self.eth.balance_of(account=self.dex_pairs.name)
self.assertEqual(pair_balance_token, token_amount + swap_amount)
# TODO - A4 - Token Supply Validations.
# Validate Supply @ UniswapV2Pair.specs.ts
total_supply = self.dex_pairs.total_supply(
tau_contract=self.tau.name, token_contract=self.eth.name)
def test_4_burn(self):
self.change_signer(self.wallet_address)
tau_amount = 3
token_amount = 3
# Add liquidity
self.add_liquidity(tau_amount, token_amount)
expected_liquidity = 3
self.dex_pairs.transfer(
tau_contract=self.tau.name,
token_contract=self.eth.name,
amount=expected_liquidity -
self.expand_to_token_decimals(MINIMUM_LIQUIDITY),
to=self.dex_pairs.name)
dex_pair_lp_balance = self.dex_pairs.balance_of(
tau_contract=self.tau.name,
token_contract=self.eth.name,
account=self.dex_pairs.name)
assert dex_pair_lp_balance == expected_liquidity - self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
# transfer, transfer, transfer, sync, burn
tau_amount, token_amount = self.dex_pairs.burn_liquidity(
dex_contract=self.dex.name,
tau_contract=self.tau.name,
token_contract=self.eth.name,
to_address=self.wallet_address)
# Assert we got back everything - MINIMUM LIQUIDITY
assert tau_amount == token_amount
assert tau_amount == expected_liquidity - self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
assert token_amount == expected_liquidity - self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
tau_wallet_balance = self.tau.balance_of(account=self.wallet_address)
assert tau_wallet_balance == STARTING_BALANCE - self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
token_wallet_balance = self.eth.balance_of(account=self.wallet_address)
assert token_wallet_balance == STARTING_BALANCE - self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
# Assert that remaining balance of liquidity for wallet is 0
assert self.dex_pairs.balance_of(tau_contract=self.tau.name,
token_contract=self.eth.name,
account=self.wallet_address) == 0
# assert total supply left for token pair is the MINIMUM_LIQUIDITY
assert self.dex_pairs.total_supply(
tau_contract=self.tau.name,
token_contract=self.eth.name) == self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
# assert total currency left on currencies is only the minimum liquidity
assert self.tau.balance_of(
account=self.dex_pairs.name) == self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
assert self.eth.balance_of(
account=self.dex_pairs.name) == self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
# Test = Dex.fee_to is not initialized (feeTo is Off)
def test_5_feeTo_off(self):
tau_amount = 1000
eth_amount = 1000
self.add_liquidity(tau_amount, eth_amount)
swap_amount = 1
expected_output_amount = self.expand_to_token_decimals(
996006981039903216)
self.eth.transfer(amount=swap_amount, to=self.dex_pairs.name)
self.dex_pairs.swap(tau_contract=self.tau.name,
token_contract=self.eth.name,
tau_out=expected_output_amount,
token_out=0,
to_address='test_results_wallet')
# Validate Reserves
tau_reserve, token_reserve = self.dex_pairs.get_pair_reserves(
tau_contract=self.tau.name, token_contract=self.eth.name)
self.assertEqual(tau_reserve, tau_amount - expected_output_amount)
self.assertEqual(token_reserve, eth_amount + swap_amount)
wallet_balance_tau = self.tau.balance_of(account='test_results_wallet')
wallet_balance_token = self.eth.balance_of(
account='test_results_wallet')
self.assertEqual(wallet_balance_tau, expected_output_amount)
self.assertEqual(wallet_balance_token, 0)
expected_liquidity = 1000
self.dex_pairs.transfer(
tau_contract=self.tau.name,
token_contract=self.eth.name,
amount=expected_liquidity -
self.expand_to_token_decimals(MINIMUM_LIQUIDITY),
to=self.dex_pairs.name)
dex_pair_lp_balance = self.dex_pairs.balance_of(
tau_contract=self.tau.name,
token_contract=self.eth.name,
account=self.dex_pairs.name)
assert dex_pair_lp_balance == expected_liquidity - self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
self.dex_pairs.burn_liquidity(dex_contract=self.dex.name,
tau_contract=self.tau.name,
token_contract=self.eth.name,
to_address=self.wallet_address)
# Total supply remains as MINIMUM LIQUIDITY
pair_total_supply = self.dex_pairs.total_supply(
tau_contract=self.tau.name, token_contract=self.eth.name)
assert pair_total_supply == self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
# Test = Dex.fee_to gets initialized (feeTo is On)
def test_5_feeTo_on(self):
# Initialize dex.fee_to
self.change_signer(self.fee_to_setter_address)
self.dex.set_fee_to(account=self.fee_to_address)
self.change_signer(self.wallet_address)
tau_amount = 1000
eth_amount = 1000
self.add_liquidity(tau_amount, eth_amount)
swap_amount = 1
expected_output_amount = self.expand_to_token_decimals(
996006981039903216)
self.eth.transfer(amount=swap_amount, to=self.dex_pairs.name)
self.dex_pairs.swap(tau_contract=self.tau.name,
token_contract=self.eth.name,
tau_out=expected_output_amount,
token_out=0,
to_address='test_results_wallet')
# Validate Reserves
tau_reserve, token_reserve = self.dex_pairs.get_pair_reserves(
tau_contract=self.tau.name, token_contract=self.eth.name)
self.assertEqual(tau_reserve, tau_amount - expected_output_amount)
self.assertEqual(token_reserve, eth_amount + swap_amount)
wallet_balance_tau = self.tau.balance_of(account='test_results_wallet')
wallet_balance_token = self.eth.balance_of(
account='test_results_wallet')
self.assertEqual(wallet_balance_tau, expected_output_amount)
self.assertEqual(wallet_balance_token, 0)
expected_liquidity = 1000
self.dex_pairs.transfer(
tau_contract=self.tau.name,
token_contract=self.eth.name,
amount=expected_liquidity -
self.expand_to_token_decimals(MINIMUM_LIQUIDITY),
to=self.dex_pairs.name)
dex_pair_lp_balance = self.dex_pairs.balance_of(
tau_contract=self.tau.name,
token_contract=self.eth.name,
account=self.dex_pairs.name)
assert dex_pair_lp_balance == expected_liquidity - self.expand_to_token_decimals(
MINIMUM_LIQUIDITY)
self.dex_pairs.burn_liquidity(dex_contract=self.dex.name,
tau_contract=self.tau.name,
token_contract=self.eth.name,
to_address=self.wallet_address)
# Total supply remains as MINIMUM LIQUIDITY
# ContractingDecimal carries more precision than Ethereum bigNumber
# assert to 17 places
expected_supply = self.expand_to_token_decimals(249750499251388 +
MINIMUM_LIQUIDITY)
pair_total_supply = self.dex_pairs.total_supply(
tau_contract=self.tau.name, token_contract=self.eth.name)
self.assertAlmostEqual(pair_total_supply, expected_supply, places=17)
fee_to_balance = self.dex_pairs.balance_of(
tau_contract=self.tau.name,
token_contract=self.eth.name,
account=self.fee_to_address)
expected_fee_to_balance = self.expand_to_token_decimals(
249750499251388)
self.assertAlmostEqual(fee_to_balance,
expected_fee_to_balance,
places=17)
tau_balance = self.tau.balance_of(account=self.dex_pairs.name)
expected_tau_balance = self.expand_to_token_decimals(249501683697445 +
MINIMUM_LIQUIDITY)
self.assertAlmostEqual(tau_balance, expected_tau_balance, places=17)
token_balance = self.eth.balance_of(account=self.dex_pairs.name)
expected_token_balance = self.expand_to_token_decimals(
250000187312969 + MINIMUM_LIQUIDITY)
self.assertAlmostEqual(token_balance,
expected_token_balance,
places=17)
class TestPendingMasters(TestCase):
def setUp(self):
self.client = ContractingClient()
f = open('./contracts/currency.s.py')
self.client.submit(f.read(), 'currency')
f.close()
f = open('./contracts/election_house.s.py')
self.client.submit(f.read(), 'election_house')
f.close()
f = open('./contracts/stamp_cost.s.py')
self.client.submit(f.read(),
'stamp_cost',
owner='election_house',
constructor_args={'initial_rate': 20_000})
f.close()
f = open('./contracts/masternodes.s.py')
self.client.submit(f.read(),
'masternodes',
owner='election_house',
constructor_args={
'initial_masternodes': ['stu', 'raghu'],
'initial_open_seats': 0
})
f.close()
self.client.submit(pending_masters)
self.pending_masters = self.client.get_contract(name='pending_masters')
self.currency = self.client.get_contract(name='currency')
self.stamp_cost = self.client.get_contract(name='stamp_cost')
self.election_house = self.client.get_contract(name='election_house')
self.election_house.register_policy(contract='stamp_cost')
def tearDown(self):
self.client.flush()
def test_register(self):
self.pending_masters.register(signer='stu')
q = self.pending_masters.Q.get()
self.assertEqual(q['stu'], 0)
def test_register_twice_throws_assertion_error(self):
self.pending_masters.register(signer='stu')
with self.assertRaises(AssertionError):
self.pending_masters.register(signer='stu')
def test_vote_for_someone_not_registered_throws_assertion_error(self):
with self.assertRaises(AssertionError):
self.pending_masters.vote(address='stu')
def test_vote_for_someone_registered_deducts_tau_and_adds_vote(self):
self.pending_masters.register(signer='joe')
self.currency.approve(signer='stu',
amount=10_000,
to='pending_masters')
env = {'now': Datetime._from_datetime(dt.today())}
self.pending_masters.vote(signer='stu', address='joe', environment=env)
self.assertEqual(self.currency.balances['stu'], 999999)
self.assertEqual(self.pending_masters.Q.get()['joe'], 1)
self.assertEqual(self.currency.balances['blackhole'], 1)
self.assertEqual(self.pending_masters.S['last_voted', 'stu'],
env['now'])
def test_voting_again_too_soon_throws_assertion_error(self):
self.pending_masters.register(signer='joe')
self.currency.approve(signer='stu',
amount=10_000,
to='pending_masters')
env = {'now': Datetime._from_datetime(dt.today())}
self.pending_masters.vote(signer='stu', address='joe', environment=env)
with self.assertRaises(AssertionError):
self.pending_masters.vote(signer='stu',
address='joe',
environment=env)
def test_voting_again_after_waiting_one_day_works(self):
self.pending_masters.register(signer='joe')
self.currency.approve(signer='stu',
amount=10_000,
to='pending_masters')
env = {'now': Datetime._from_datetime(dt.today())}
self.pending_masters.vote(signer='stu', address='joe', environment=env)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
self.pending_masters.vote(signer='stu', address='joe', environment=env)
self.assertEqual(self.currency.balances['stu'], 999998)
self.assertEqual(self.pending_masters.Q.get()['joe'], 2)
self.assertEqual(self.currency.balances['blackhole'], 2)
self.assertEqual(self.pending_masters.S['last_voted', 'stu'],
env['now'])
@export
def hello():
return 'Hello World!'
@export
def add(a: int, b: int):
return private_add(a, b)
def private_add(a, b):
return a + b
from contracting.client import ContractingClient
# Client to interact with local contracts
client = ContractingClient()
# Submit contract locally
client.submit(greeting)
# List all locally available contracts
print("contracts", client.get_contracts())
# Retrieve local contract
greeting = client.get_contract("greeting")
# Execute contract method 'hello()'
print("greeting - hello()", greeting.hello())
# Execute contract method 'add()'
print("greeting - add()", greeting.add(a=1, b=3))
class TestFullFlowWithMocks(TestCase):
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.driver = ContractDriver(driver=InMemDriver())
self.client = ContractingClient(driver=self.driver)
self.client.flush()
asyncio.set_event_loop(self.loop)
def tearDown(self):
self.client.flush()
self.driver.flush()
self.ctx.destroy()
self.loop.close()
def test_mock_network_init_makes_correct_number_of_nodes(self):
n = mocks.MockNetwork(num_of_delegates=1, num_of_masternodes=1, ctx=self.ctx)
self.assertEqual(len(n.masternodes), 1)
self.assertEqual(len(n.delegates), 1)
def test_mock_network_init_makes_correct_number_of_nodes_many_nodes(self):
n = mocks.MockNetwork(num_of_delegates=123, num_of_masternodes=143, ctx=self.ctx)
self.assertEqual(len(n.masternodes), 143)
self.assertEqual(len(n.delegates), 123)
def test_mock_network_init_creates_correct_bootnodes(self):
# 2 mn, 3 delegate
expected_ips = [
'tcp://127.0.0.1:18000',
'tcp://127.0.0.1:18001',
'tcp://127.0.0.1:18002',
'tcp://127.0.0.1:18003',
'tcp://127.0.0.1:18004',
]
n = mocks.MockNetwork(num_of_masternodes=2, num_of_delegates=3, ctx=self.ctx)
self.assertEqual(n.masternodes[0].ip, expected_ips[0])
self.assertEqual(n.masternodes[1].ip, expected_ips[1])
self.assertEqual(n.delegates[0].ip, expected_ips[2])
self.assertEqual(n.delegates[1].ip, expected_ips[3])
self.assertEqual(n.delegates[2].ip, expected_ips[4])
def test_startup_with_manual_node_creation_and_single_block_works(self):
m = mocks.MockMaster(ctx=self.ctx, index=1)
d = mocks.MockDelegate(ctx=self.ctx, index=2)
bootnodes = {
m.wallet.verifying_key: m.ip,
d.wallet.verifying_key: d.ip
}
constitution = {
'masternodes': [m.wallet.verifying_key],
'delegates': [d.wallet.verifying_key]
}
m.set_start_variables(bootnodes, constitution)
d.set_start_variables(bootnodes, constitution)
sender = Wallet()
async def test():
await asyncio.gather(
m.start(),
d.start()
)
tx_1 = transaction.build_transaction(
wallet=mocks.TEST_FOUNDATION_WALLET,
contract='currency',
function='transfer',
kwargs={
'amount': 1_000_000,
'to': sender.verifying_key
},
stamps=10000,
nonce=0,
processor=m.wallet.verifying_key
)
tx_2 = transaction.build_transaction(
wallet=sender,
contract='currency',
function='transfer',
kwargs={
'amount': 1338,
'to': 'jeff'
},
stamps=5000,
nonce=0,
processor=m.wallet.verifying_key
)
async with httpx.AsyncClient() as client:
await client.post('http://0.0.0.0:18081/', data=tx_1)
await asyncio.sleep(2)
await client.post('http://0.0.0.0:18081/', data=tx_2)
await asyncio.sleep(2)
await asyncio.sleep(2)
m.stop()
d.stop()
self.loop.run_until_complete(test())
# dbal = dld.get_var(contract='currency', variable='balances', arguments=['jeff'])
mbal = m.driver.get_var(contract='currency', variable='balances', arguments=['jeff'])
# self.assertEqual(dbal, 1338)
self.assertEqual(mbal, 1338)
def test_startup_and_blocks_from_network_object_works(self):
network = mocks.MockNetwork(ctx=self.ctx, num_of_masternodes=1, num_of_delegates=1)
sender = Wallet()
async def test():
await network.start()
network.refresh()
await network.make_and_push_tx(
wallet=mocks.TEST_FOUNDATION_WALLET,
contract='currency',
function='transfer',
kwargs={
'amount': 1_000_000,
'to': sender.verifying_key
}
)
await asyncio.sleep(2)
await network.make_and_push_tx(
wallet=sender,
contract='currency',
function='transfer',
kwargs={
'amount': 1338,
'to': 'jeff'
}
)
await asyncio.sleep(2)
await network.make_and_push_tx(
wallet=sender,
contract='currency',
function='transfer',
kwargs={
'amount': 444,
'to': 'stu'
}
)
await asyncio.sleep(2)
network.stop()
class TestPendingMasters(TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
f = open('./contracts/currency.s.py')
self.client.submit(f.read(), 'currency')
f.close()
f = open('./contracts/election_house.s.py')
self.client.submit(f.read(), 'election_house')
f.close()
f = open('./contracts/stamp_cost.s.py')
self.client.submit(f.read(),
'stamp_cost',
owner='election_house',
constructor_args={'initial_rate': 20_000})
f.close()
f = open('./contracts/members.s.py')
self.client.submit(
f.read(),
'masternodes',
owner='election_house',
constructor_args={'initial_members': ['stux', 'raghu']})
f.close()
f = open('./contracts/elect_members.s.py')
self.client.submit(f.read(),
'elect_members',
constructor_args={'policy': 'masternodes'})
f.close()
self.elect_members = self.client.get_contract(name='elect_members')
self.currency = self.client.get_contract(name='currency')
self.masternodes = self.client.get_contract(name='masternodes')
self.stamp_cost = self.client.get_contract(name='stamp_cost')
self.election_house = self.client.get_contract(name='election_house')
self.election_house.register_policy(contract='stamp_cost')
self.election_house.register_policy(contract='masternodes')
def tearDown(self):
self.client.flush()
def test_register(self):
self.currency.approve(signer='stu', amount=100_000, to='elect_members')
self.elect_members.register(signer='stu')
q = self.elect_members.candidate_state['votes', 'stu']
self.assertEqual(q, 0)
self.assertEqual(self.currency.balances['elect_members'], 100_000)
self.assertEqual(
self.elect_members.candidate_state['registered', 'stu'], True)
def test_double_register_raises_assert(self):
self.currency.approve(signer='stu', amount=100_000, to='elect_members')
self.elect_members.register(signer='stu')
self.currency.approve(signer='stu', amount=100_000, to='elect_members')
with self.assertRaises(AssertionError):
self.elect_members.register(signer='stu')
def test_unregister_returns_currency(self):
b1 = self.currency.balances['stu']
self.currency.approve(signer='stu', amount=100_000, to='elect_members')
self.elect_members.register(signer='stu')
self.assertEqual(self.currency.balances['stu'], b1 - 100_000)
self.elect_members.unregister(signer='stu')
self.assertEqual(self.currency.balances['stu'], b1)
def test_unregister_if_in_masternodes_throws_assert(self):
self.currency.approve(signer='stu', amount=100_000, to='elect_members')
self.elect_members.register(signer='stu')
self.masternodes.S['masternodes'] = ['stu', 'raghu']
with self.assertRaises(AssertionError):
self.elect_members.unregister()
def test_unregister_if_not_registered_throws_assert(self):
with self.assertRaises(AssertionError):
self.elect_members.unregister()
def test_vote_for_someone_not_registered_throws_assertion_error(self):
with self.assertRaises(AssertionError):
self.elect_members.vote_candidate(address='stu')
def test_vote_for_someone_registered_deducts_tau_and_adds_vote(self):
# Give joe money
self.currency.transfer(signer='stu', amount=100_000, to='joe')
# Joe Allows Spending
self.currency.approve(signer='joe', amount=100_000, to='elect_members')
self.elect_members.register(signer='joe')
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
stu_bal = self.currency.balances['stu']
self.elect_members.vote_candidate(signer='stu',
address='joe',
environment=env)
self.assertEqual(self.currency.balances['stu'], stu_bal - 1)
self.assertEqual(self.elect_members.candidate_state['votes', 'joe'], 1)
self.assertEqual(self.currency.balances['blackhole'], 1)
self.assertEqual(
self.elect_members.candidate_state['last_voted', 'stu'],
env['now'])
def test_voting_again_too_soon_throws_assertion_error(self):
# Give joe money
self.currency.transfer(signer='stu', amount=100_000, to='joe')
# Joe Allows Spending
self.currency.approve(signer='joe', amount=100_000, to='elect_members')
self.elect_members.register(signer='joe')
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_candidate(signer='stu',
address='joe',
environment=env)
with self.assertRaises(AssertionError):
self.elect_members.vote_candidate(signer='stu',
address='joe',
environment=env)
def test_voting_again_after_waiting_one_day_works(self):
# Give joe money
self.currency.transfer(signer='stu', amount=100_000, to='joe')
# Joe Allows Spending
self.currency.approve(signer='joe', amount=100_000, to='elect_members')
self.elect_members.register(signer='joe')
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
stu_bal = self.currency.balances['stu']
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_candidate(signer='stu',
address='joe',
environment=env)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
self.elect_members.vote_candidate(signer='stu',
address='joe',
environment=env)
self.assertEqual(self.currency.balances['stu'], stu_bal - 2)
self.assertEqual(self.elect_members.candidate_state['votes', 'joe'], 2)
self.assertEqual(self.currency.balances['blackhole'], 2)
self.assertEqual(
self.elect_members.candidate_state['last_voted', 'stu'],
env['now'])
def test_top_masternode_returns_none_if_no_candidates(self):
self.assertIsNone(self.elect_members.top_member())
def test_top_masternode_returns_joe_if_registered_but_no_votes(self):
self.currency.transfer(signer='stu', amount=100_000,
to='joe') # Give joe money
self.currency.approve(signer='joe', amount=100_000,
to='elect_members') # Joe Allows Spending
self.elect_members.register(signer='joe') # Register Joe
self.assertEqual(self.elect_members.top_member(),
'joe') # Joe is the current top spot
def test_top_masternode_returns_bob_if_joe_and_bob_registered_but_bob_has_votes(
self):
self.currency.transfer(signer='stu', amount=100_000,
to='joe') # Give joe money
self.currency.approve(signer='joe', amount=100_000,
to='elect_members') # Joe Allows Spending
self.elect_members.register(signer='joe') # Register Joe
self.currency.transfer(signer='stu', amount=100_000,
to='bob') # Give Bob money
self.currency.approve(signer='bob', amount=100_000,
to='elect_members') # Bob Allows Spending
self.elect_members.register(signer='bob') # Register Bob
self.currency.approve(
signer='stu', amount=10_000,
to='elect_members') # Stu approves spending to vote
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_candidate(signer='stu',
address='bob',
environment=env) # Stu votes for Bob
self.assertEqual(self.elect_members.top_member(),
'bob') # bob is the current top spot
def test_top_masternode_returns_joe_if_joe_and_bob_registered_but_joe_first_and_no_votes(
self):
self.currency.transfer(signer='stu', amount=100_000,
to='joe') # Give joe money
self.currency.approve(signer='joe', amount=100_000,
to='elect_members') # Joe Allows Spending
self.elect_members.register(signer='joe') # Register Joe
self.currency.transfer(signer='stu', amount=100_000,
to='bob') # Give Bob money
self.currency.approve(signer='bob', amount=100_000,
to='elect_members') # Bob Allows Spending
self.elect_members.register(signer='bob') # Register Bob
self.assertEqual(self.elect_members.top_member(),
'joe') # Joe is the current top spot
def test_pop_top_fails_if_not_masternodes_contract(self):
with self.assertRaises(AssertionError):
self.elect_members.pop_top()
def test_pop_top_doesnt_fail_if_masternode_contract(self):
self.elect_members.pop_top(signer='masternodes')
def test_pop_top_deletes_bob_if_pop_is_top_masternode(self):
self.currency.transfer(signer='stu', amount=100_000,
to='joe') # Give joe money
self.currency.approve(signer='joe', amount=100_000,
to='elect_members') # Joe Allows Spending
self.elect_members.register(signer='joe') # Register Joe
self.currency.transfer(signer='stu', amount=100_000,
to='bob') # Give Bob money
self.currency.approve(signer='bob', amount=100_000,
to='elect_members') # Bob Allows Spending
self.elect_members.register(signer='bob') # Register Bob
self.currency.approve(
signer='stu', amount=10_000,
to='elect_members') # Stu approves spending to vote
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_candidate(signer='stu',
address='bob',
environment=env) # Stu votes for Bob
self.assertEqual(self.elect_members.top_member(),
'bob') # bob is the current top spot
self.assertIsNotNone(self.elect_members.candidate_state['votes',
'bob'])
self.elect_members.pop_top(signer='masternodes')
self.assertIsNone(self.elect_members.candidate_state['votes', 'bob'])
def test_pop_top_returns_none_if_noone_registered(self):
self.assertIsNone(self.elect_members.pop_top(signer='masternodes'))
def test_voting_no_confidence_against_non_committee_member_fails(self):
with self.assertRaises(AssertionError):
self.elect_members.vote_no_confidence(address='whoknows')
def test_vote_no_confidence_for_someone_registered_deducts_tau_and_adds_vote(
self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
stu_bal = self.currency.balances['stu']
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(
signer='stu', address='raghu',
environment=env) # Raghu is seeded in contract
self.assertEqual(self.currency.balances['stu'], stu_bal - 1)
self.assertEqual(
self.elect_members.no_confidence_state['votes', 'raghu'], 1)
self.assertEqual(self.currency.balances['blackhole'], 1)
self.assertEqual(
self.elect_members.no_confidence_state['last_voted', 'stu'],
env['now'])
def test_voting_no_confidence_again_too_soon_throws_assertion_error(self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
with self.assertRaises(AssertionError):
self.elect_members.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
def test_voting_no_confidence_again_after_waiting_one_day_works(self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
stu_bal = self.currency.balances['stu']
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
self.elect_members.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
self.assertEqual(self.currency.balances['stu'], stu_bal - 2)
self.assertEqual(
self.elect_members.no_confidence_state['votes', 'raghu'], 2)
self.assertEqual(self.currency.balances['blackhole'], 2)
self.assertEqual(
self.elect_members.no_confidence_state['last_voted', 'stu'],
env['now'])
def test_last_masternode_returns_none_if_no_candidates(self):
self.assertIsNone(self.elect_members.last_member())
def test_last_masternode_returns_none_if_no_votes(self):
self.assertEqual(self.elect_members.last_member(),
None) # Joe is the current top spot
def test_relinquish_fails_if_not_in_masternodes(self):
with self.assertRaises(AssertionError):
self.elect_members.relinquish(signer='joebob')
def test_relinquish_adds_ctx_signer_if_in_masternodes(self):
self.elect_members.relinquish(signer='raghu')
self.assertEqual('raghu', self.elect_members.to_be_relinquished.get())
def test_last_masternode_returns_relinquished_if_there_is_one_to_be_relinquished(
self):
self.elect_members.relinquish(signer='raghu')
self.assertEqual(self.elect_members.last_member(), 'raghu')
def test_error_if_someone_tries_to_relinquish_when_another_exists(self):
self.elect_members.relinquish(signer='raghu')
with self.assertRaises(AssertionError):
self.elect_members.relinquish(signer='stux')
def test_last_masternode_returns_masternode_with_most_votes_if_none_in_relinquished(
self):
self.currency.approve(
signer='stu', amount=10_000,
to='elect_members') # Stu approves spending to vote
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(
signer='stu', address='raghu',
environment=env) # Stu votes for Bob
self.assertEqual(self.elect_members.last_member(),
'raghu') # bob is the current top spot
def test_last_masternode_returns_first_in_if_tie(self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(signer='stu',
address='stux',
environment=env)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
self.elect_members.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
self.assertEqual(self.elect_members.last_member(), 'stux')
def test_last_masternode_returns_least_popular_if_multiple_votes(self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(signer='stu',
address='stux',
environment=env)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
self.elect_members.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
env = {'now': Datetime._from_datetime(dt.today() + td(days=14))}
self.elect_members.vote_no_confidence(signer='stu',
address='stux',
environment=env)
self.assertEqual(self.elect_members.last_member(), 'stux')
def test_pop_last_fails_if_not_masternodes_contract(self):
with self.assertRaises(AssertionError):
self.elect_members.pop_last()
def test_pop_last_doesnt_fail_if_masternodes_contract(self):
self.elect_members.pop_last(signer='masternodes')
def test_pop_last_deletes_stux_if_is_last_masternode_and_no_relinquished(
self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(signer='stu',
address='stux',
environment=env)
self.assertIsNotNone(self.elect_members.no_confidence_state['votes',
'stux'])
self.elect_members.pop_last(signer='masternodes')
self.assertIsNone(self.elect_members.no_confidence_state['votes',
'stux'])
def test_pop_last_deletes_raghu_if_stux_voted_but_raghu_relinquished(self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(signer='stu',
address='stux',
environment=env)
self.elect_members.relinquish(signer='raghu')
self.assertIsNotNone(self.elect_members.no_confidence_state['votes',
'stux'])
self.assertIn('raghu', self.elect_members.to_be_relinquished.get())
self.elect_members.pop_last(signer='masternodes')
self.assertIsNone(self.elect_members.to_be_relinquished.get())
self.assertIsNotNone(self.elect_members.no_confidence_state['votes',
'stux'])
def test_pop_last_deletes_raghu_from_no_confidence_hash_if_relinquished(
self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
self.elect_members.relinquish(signer='raghu')
self.assertIsNotNone(self.elect_members.no_confidence_state['votes',
'raghu'])
self.assertIn('raghu', self.elect_members.to_be_relinquished.get())
self.elect_members.pop_last(signer='masternodes')
self.assertIsNone(self.elect_members.to_be_relinquished.get())
self.assertEqual(
self.elect_members.no_confidence_state['votes', 'raghu'], 0)
def test_no_confidence_pop_last_prevents_unregistering(self):
# Give Raghu money
self.currency.transfer(signer='stu', amount=100_000, to='raghu')
# Raghu Allows Spending
self.currency.approve(signer='raghu',
amount=100_000,
to='elect_members')
self.elect_members.register(signer='raghu')
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
self.elect_members.vote_no_confidence(signer='stu', address='raghu')
self.elect_members.pop_last(signer='masternodes')
self.assertFalse(self.elect_members.candidate_state['registered',
'raghu'])
with self.assertRaises(AssertionError):
self.elect_members.unregister(signer='raghu')
def test_relinquish_pop_last_allows_unregistering(self):
# Give Raghu money
self.currency.transfer(signer='stu', amount=100_000, to='raghu')
# Raghu Allows Spending
self.currency.approve(signer='raghu',
amount=100_000,
to='elect_members')
self.elect_members.register(signer='raghu')
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
self.elect_members.vote_no_confidence(signer='stu', address='raghu')
self.elect_members.relinquish(signer='raghu')
self.elect_members.pop_last(signer='masternodes')
self.assertTrue(self.elect_members.candidate_state['registered',
'raghu'])
self.masternodes.quick_write('S', 'members', ['stu'])
self.elect_members.unregister(signer='raghu')
def test_force_removal_fails_if_not_masternodes(self):
with self.assertRaises(AssertionError):
self.elect_members.force_removal(address='stux')
def test_force_removal_unregisters_address(self):
# Give Raghu money
self.currency.transfer(signer='stu', amount=100_000, to='stux')
# Raghu Allows Spending
self.currency.approve(signer='stux',
amount=100_000,
to='elect_members')
self.elect_members.register(signer='stux')
self.elect_members.force_removal(signer='masternodes', address='stux')
self.assertFalse(self.elect_members.candidate_state['registered',
'stux'])
class TestMasternodePolicy(TestCase):
def setUp(self):
self.client = ContractingClient()
f = open('./contracts/currency.s.py')
self.client.submit(f.read(), 'currency')
f.close()
with open('./contracts/election_house.s.py') as f:
contract = f.read()
self.client.submit(contract, name='election_house')
f = open('./contracts/master_candidates.s.py')
self.client.submit(f.read(), 'master_candidates')
f.close()
f = open('./contracts/stamp_cost.s.py')
self.client.submit(f.read(),
'stamp_cost',
owner='election_house',
constructor_args={'initial_rate': 20_000})
f.close()
self.election_house = self.client.get_contract('election_house')
self.stamp_cost = self.client.get_contract(name='stamp_cost')
self.election_house.register_policy(contract='stamp_cost')
self.master_candidates = self.client.get_contract('master_candidates')
self.currency = self.client.get_contract('currency')
def tearDown(self):
self.client.flush()
def test_init(self):
self.client.submit(masternodes,
owner='election_house',
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
self.assertEqual(mn_contract.current_value(signer='election_house'),
[1, 2, 3])
self.assertEqual(mn_contract.S['yays'], 0)
self.assertEqual(mn_contract.S['nays'], 0)
self.assertEqual(mn_contract.S['current_motion'], 0)
def test_voter_not_masternode_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk='sys',
action='introduce_motion',
position=1)
def test_vote_invalid_action_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='xxx',
position=1)
def test_vote_on_motion_bool_succeeds(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='vote_on_motion',
position=True)
def test_action_introduce_motion_current_motion_not_no_motion_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write(variable='S', key='current_motion', value=1)
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1)
def test_action_introduce_motion_out_of_range_motion_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=10)
def test_action_introduce_motion_no_arg_provided_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1)
def test_action_introduce_motion_vk_not_str_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1,
arg=True)
def test_action_introduce_motion_vk_not_64_chars_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1,
arg='a')
def test_action_introduce_motion_not_valid_hex_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(ValueError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1,
arg='x' * 64,
signer='x' * 64)
def test_action_vote_on_motion_fails_if_not_bool(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(
f='assert_vote_is_valid',
vk=1,
action='vote_on_motion',
position=1,
)
def test_vote_not_tuple_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 'sys'],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.vote(vk='sys', obj={'hanky': 'panky'})
def test_vote_1_elem_tuple_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 'sys'],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(ValueError):
mn_contract.vote(vk='sys', obj=(1, ))
def test_vote_4_elem_tuple_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 'sys'],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(ValueError):
mn_contract.vote(vk='sys', obj=(1, 2, 3, 4))
# ADD_MASTER = 1
# REMOVE_MASTER = 2
# ADD_SEAT = 3
# REMOVE_SEAT = 4
def test_introduce_motion_remove_seat_fails_if_position_out_of_index(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='introduce_motion',
position=4,
arg=None)
def test_introduce_motion_remove_seat_works_and_sets_position_and_motion_opened(
self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'open_seats', 1)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
mn_contract.run_private_function(f='introduce_motion',
position=3,
arg=None,
environment=env)
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 3)
self.assertEqual(mn_contract.quick_read('S', 'motion_opened'),
env['now'])
def test_add_master_or_remove_master_adds_arg(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': ['abc', 'bcd', 'cde'],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'open_seats', 1)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
mn_contract.run_private_function(f='introduce_motion',
position=1,
arg='abc',
environment=env)
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 1)
self.assertEqual(mn_contract.quick_read('S', 'motion_opened'),
env['now'])
self.assertEqual(mn_contract.quick_read('S', 'master_in_question'),
'abc')
def test_remove_master_that_does_not_exist_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(
f='introduce_motion',
position=1,
arg='abc',
)
def test_remove_master_that_exists_passes(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.run_private_function(
f='introduce_motion',
position=2,
arg=1,
)
def test_pass_current_motion_add_master_appends_and_removes_seat(self):
# Give joe money
self.currency.transfer(signer='stu', amount=100_000, to='joe')
# Joe Allows Spending
self.currency.approve(signer='joe',
amount=100_000,
to='master_candidates')
self.master_candidates.register(signer='joe')
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'current_motion', 2)
mn_contract.run_private_function(f='pass_current_motion', )
self.assertEqual(mn_contract.quick_read('S', 'masternodes'),
[1, 2, 3, 'joe'])
def test_pass_current_motion_remove_master_adds_new_seat_and_removes_master(
self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'master_in_question', 1)
mn_contract.quick_write('S', 'current_motion', 1)
mn_contract.run_private_function(f='pass_current_motion', )
self.assertEqual(mn_contract.quick_read('S', 'masternodes'), [2, 3])
def test_pass_remove_seat_removes_least_popular(self):
self.client.submit(masternodes,
owner='election_house',
constructor_args={
'initial_masternodes': ['abc', 'bcd', 'def'],
})
self.election_house.register_policy(contract='masternodes')
self.currency.approve(signer='stu',
amount=100_000,
to='master_candidates')
self.master_candidates.vote_no_confidence(signer='stu', address='bcd')
self.election_house.vote(signer='abc',
policy='masternodes',
value=('introduce_motion', 3))
self.election_house.vote(signer='bcd',
policy='masternodes',
value=('vote_on_motion', True))
self.election_house.vote(signer='def',
policy='masternodes',
value=('vote_on_motion', True))
self.assertListEqual(
self.election_house.current_value_for_policy(policy='masternodes'),
['abc', 'def'])
def test_pass_remove_seat_removes_relinquished_first(self):
self.client.submit(masternodes,
owner='election_house',
constructor_args={
'initial_masternodes': ['abc', 'bcd', 'def'],
})
self.election_house.register_policy(contract='masternodes')
self.master_candidates.relinquish(signer='abc')
self.election_house.vote(signer='abc',
policy='masternodes',
value=('introduce_motion', 3))
self.election_house.vote(signer='bcd',
policy='masternodes',
value=('vote_on_motion', True))
self.election_house.vote(signer='def',
policy='masternodes',
value=('vote_on_motion', True))
self.assertListEqual(
self.election_house.current_value_for_policy(policy='masternodes'),
['bcd', 'def'])
def test_remove_seat_not_current_masternode_fails(self):
self.client.submit(masternodes,
owner='election_house',
constructor_args={
'initial_masternodes': ['abc', 'bcd', 'def'],
})
self.election_house.register_policy(contract='masternodes')
with self.assertRaises(AssertionError):
self.election_house.vote(signer='abc',
policy='masternodes',
value=('introduce_motion', 1, 'blah'))
def test_pass_add_seat_adds_most_popular(self):
# Give joe money
self.currency.transfer(signer='stu', amount=100_000, to='joe')
# Joe Allows Spending
self.currency.approve(signer='joe',
amount=100_000,
to='master_candidates')
self.master_candidates.register(signer='joe')
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.vote(vk=1, obj=('introduce_motion', 2))
mn_contract.vote(vk=2, obj=('vote_on_motion', True))
mn_contract.vote(vk=3, obj=('vote_on_motion', True))
self.assertListEqual(mn_contract.current_value(), [1, 2, 3, 'joe'])
def test_current_value_returns_dict(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
d = mn_contract.current_value()
self.assertEqual(d, [1, 2, 3])
# S['current_motion'] = NO_MOTION
# S['master_in_question'] = None
# S['votes'] = 0
# S.clear('positions')
def test_reset_alters_state_correctly(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'current_motion', 1)
mn_contract.quick_write('S', 'master_in_question', 'abc')
mn_contract.quick_write('S', 'yays', 100)
mn_contract.quick_write('S', 'nays', 999)
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id1'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id2'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id3'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id4'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id5'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id6'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id7'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id8'])
mn_contract.run_private_function(f='reset', )
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 0)
self.assertEqual(mn_contract.quick_read('S', 'master_in_question'),
None)
self.assertEqual(mn_contract.quick_read('S', 'yays'), 0)
self.assertEqual(mn_contract.quick_read('S', 'nays'), 0)
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id1']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id2']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id3']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id4']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id5']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id6']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id7']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id8']))
def test_vote_introduce_motion_affects_state_when_done_properly(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=('introduce_motion', 3),
environment=env)
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 3)
self.assertEqual(mn_contract.quick_read('S', 'motion_opened'),
env['now'])
def test_vote_no_motion_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
with self.assertRaises(AssertionError):
mn_contract.vote(vk='a' * 64,
obj=('vote_on_motion', False),
environment=env)
def test_vote_on_motion_works(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=('introduce_motion', 3),
environment=env)
mn_contract.vote(vk='b' * 64, obj=('vote_on_motion', True))
self.assertEqual(mn_contract.quick_read('S', 'yays'), 1)
self.assertEqual(
mn_contract.quick_read(variable='S',
key='positions',
args=['b' * 64]), True)
def test_vote_on_motion_works_nays(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=('introduce_motion', 3),
environment=env)
mn_contract.vote(vk='b' * 64, obj=('vote_on_motion', False))
self.assertEqual(mn_contract.quick_read('S', 'nays'), 1)
self.assertEqual(mn_contract.quick_read('S', 'yays'), 0)
self.assertEqual(
mn_contract.quick_read(variable='S',
key='positions',
args=['b' * 64]), False)
def test_vote_on_motion_twice_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=('introduce_motion', 3),
environment=env)
mn_contract.vote(vk='b' * 64, obj=('vote_on_motion', True))
with self.assertRaises(AssertionError):
mn_contract.vote(vk='b' * 64, obj=('vote_on_motion', False))
def test_vote_reaches_more_than_half_passes(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=('introduce_motion', 3),
environment=env)
mn_contract.vote(vk='a' * 64, obj=('vote_on_motion', True))
mn_contract.vote(vk='b' * 64, obj=('vote_on_motion', True))
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 0)
self.assertEqual(mn_contract.quick_read('S', 'master_in_question'),
None)
self.assertEqual(mn_contract.quick_read('S', 'yays'), 0)
def test_vote_reaches_more_than_half_nays_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=('introduce_motion', 3),
environment=env)
mn_contract.vote(vk='a' * 64, obj=('vote_on_motion', False))
mn_contract.vote(vk='b' * 64, obj=('vote_on_motion', False))
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 0)
self.assertEqual(mn_contract.quick_read('S', 'master_in_question'),
None)
self.assertEqual(mn_contract.quick_read('S', 'nays'), 0)
def test_vote_doesnt_reach_consensus_after_voting_period_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=('introduce_motion', 3),
environment=env)
env = {'now': Datetime._from_datetime(dt.today() + td(days=2))}
mn_contract.vote(vk='a' * 64,
obj=('vote_on_motion', True),
environment=env)
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 0)
self.assertEqual(mn_contract.quick_read('S', 'master_in_question'),
None)
self.assertEqual(mn_contract.quick_read('S', 'nays'), 0)
class TestBetterElectionHouse(TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
self.client.submit(election_house, name='election_house2')
self.election_house = self.client.get_contract(name='election_house2')
def tearDown(self):
self.client.flush()
def test_register_doesnt_fail(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
def test_register_without_owner_fails(self):
self.client.submit(test_policy)
with self.assertRaises(AssertionError):
self.election_house.register_policy(policy='testing',
contract='test_policy')
def test_register_same_contract_twice_fails(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
with self.assertRaises(Exception):
self.election_house.register_policy(policy='testing',
contract='test_policy')
def test_register_contract_without_entire_interface_fails(self):
self.client.submit(test_policy, owner='election_house2')
with self.assertRaises(Exception):
self.election_house.register_policy(policy='testing',
contract='bad_interface')
def test_register_same_contract_under_another_name_fails(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
with self.assertRaises(Exception):
self.election_house.register_policy(policy='testing2',
contract='test_policy')
def test_current_value_for_policy_returns_correct_value(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
res = self.election_house.current_value_for_policy(policy='testing')
self.assertEqual(res, '1234')
def test_current_value_for_non_existant_policy_fails(self):
self.client.submit(test_policy, owner='election_house2')
with self.assertRaises(AssertionError):
self.election_house.current_value_for_policy(policy='testing')
def test_vote_delegate_calls_policy(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
self.election_house.vote(policy='testing', value='5678')
def test_full_vote_flow_works(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
self.election_house.vote(policy='testing', value='5678')
res = self.election_house.current_value_for_policy(policy='testing')
self.assertEqual(res, '5678')
class TestBlockManager(TestCase):
def setUp(self):
self.loop = asyncio.get_event_loop()
self.ctx = zmq.asyncio.Context()
self.client = ContractingClient()
def tearDown(self):
self.ctx.destroy()
self.loop.stop()
self.client.flush()
def test_init(self):
b = Delegate(socket_base='tcp://127.0.0.1',
wallet=Wallet(),
ctx=self.ctx,
bootnodes=bootnodes,
constitution=constitution)
def test_execute_work_single_transaction(self):
test_contract = '''
v = Variable()
@construct
def seed():
v.set('hello')
@export
def set(var):
v.set(var)
@export
def get():
return v.get()
'''
self.client.submit(test_contract, name='testing')
tx = TransactionBuilder(sender='stu',
contract='testing',
function='set',
kwargs={'var': 'jeff'},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0)
tx.sign(Wallet().signing_key())
tx.serialize()
tx_batch = transaction_list_to_transaction_batch([tx.struct],
wallet=Wallet())
b = Delegate(socket_base='tcp://127.0.0.1',
wallet=Wallet(),
ctx=self.ctx,
bootnodes=bootnodes,
constitution=constitution)
b.execute_work([(1, tx_batch)])
def test_execute_multiple_tx_in_batch_returns_correct_sbc(self):
test_contract = '''
v = Variable()
@construct
def seed():
v.set('hello')
@export
def set(var):
v.set(var)
@export
def get():
return v.get()
'''
self.client.submit(test_contract, name='testing')
tx = TransactionBuilder(sender='stu',
contract='testing',
function='set',
kwargs={'var': 'howdy'},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0)
tx.sign(Wallet().signing_key())
tx.serialize()
tx2 = TransactionBuilder(sender='stu',
contract='testing',
function='get',
kwargs={},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0)
tx2.sign(Wallet().signing_key())
tx2.serialize()
tx_batch = transaction_list_to_transaction_batch(
[tx.struct, tx2.struct], wallet=Wallet())
w = Wallet()
b = Delegate(socket_base='tcp://127.0.0.1', wallet=w, ctx=self.ctx)
results = b.execute_work([(tx_batch.timestamp, tx_batch)])
# Test that there is a state change on the 1st tx
tx = results[0].transactions[0]
self.assertEqual(tx.state[0].key, b'testing.v')
self.assertEqual(tx.state[0].value, b'"howdy"')
self.assertEqual(results[0].inputHash, tx_batch.inputHash)
self.assertEqual(results[0].prevBlockHash, b'\x00' * 32)
self.assertEqual(results[0].signer, w.verifying_key())
def test_environment_variables_are_working_as_they_should(self):
test_contract = '''
a = Variable()
b = Variable()
c = Variable()
@export
def capture():
a.set(block_hash)
b.set(block_num)
c.set(now)
'''
self.client.submit(test_contract, name='testing')
tx = TransactionBuilder(sender='stu',
contract='testing',
function='capture',
kwargs={},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0)
tx.sign(Wallet().signing_key())
tx.serialize()
tx_batch = transaction_list_to_transaction_batch([tx.struct],
wallet=Wallet())
w = Wallet()
b = Delegate(socket_base='tcp://127.0.0.1', wallet=w, ctx=self.ctx)
now = Datetime._from_datetime(
datetime.utcfromtimestamp(tx_batch.timestamp))
results = b.execute_work([(tx_batch.timestamp, tx_batch)])
tx = results[0].transactions[0]
a, b, c = tx.state
self.assertEqual(a.key, b'testing.a')
self.assertEqual(
a.value,
b'"0000000000000000000000000000000000000000000000000000000000000000"'
)
self.assertEqual(b.key, b'testing.b')
self.assertEqual(b.value, b'0')
self.assertEqual(c.key, b'testing.c')
self.assertEqual(c.value, encode(now).encode())
def test_build_sbc_from_work_results(self):
test_contract = '''
v = Variable()
@construct
def seed():
v.set('hello')
@export
def set(var):
v.set(var)
@export
def get():
return v.get()
'''
print('ok')
self.client.submit(test_contract, name='testing')
print('here')
tx = TransactionBuilder(sender='stu',
contract='testing',
function='set',
kwargs={'var': 'jeff'},
stamps=100_000,
processor=b'\x00' * 32,
nonce=0)
tx.sign(Wallet().signing_key())
tx.serialize()
tx_batch = transaction_list_to_transaction_batch([tx.struct],
wallet=Wallet())
b = Delegate(socket_base='tcp://127.0.0.1',
wallet=Wallet(),
ctx=self.ctx,
constitution=constitution)
print(sbc)
class TestRewards(TestCase):
def setUp(self):
self.client = ContractingClient()
self.driver = self.client.raw_driver
# Sync contracts
sync.submit_from_genesis_json_file(cilantro_ee.contracts.__path__[0] +
'/genesis.json',
client=self.client)
sync.submit_node_election_contracts(
initial_masternodes=['stu', 'raghu', 'steve'],
boot_mns=2,
initial_delegates=['tejas', 'alex'],
boot_dels=3,
client=self.client)
self.r = RewardManager(driver=self.driver)
def tearDown(self):
self.client.flush()
def test_add_rewards(self):
block = random_txs.random_block()
total = 0
for sb in block.subBlocks:
for tx in sb.transactions:
total += tx.stampsUsed
self.assertEqual(self.r.stamps_in_block(block), total)
def test_add_to_balance(self):
currency_contract = self.client.get_contract('currency')
current_balance = currency_contract.quick_read(variable='balances',
key='test')
if current_balance is None:
current_balance = 0
self.assertEqual(current_balance, 0)
self.r.add_to_balance('test', 1234)
current_balance = currency_contract.quick_read(variable='balances',
key='test')
if current_balance is None:
current_balance = 0
self.assertEqual(current_balance, 1234)
self.r.add_to_balance('test', 1000)
current_balance = currency_contract.quick_read(variable='balances',
key='test')
if current_balance is None:
current_balance = 0
self.assertEqual(current_balance, 2234)
def test_stamps_per_tau_works(self):
self.assertEqual(self.r.stamps_per_tau, 20_000)
stamps = self.client.get_contract('stamp_cost')
stamps.quick_write('S', 'rate', 555)
self.assertEqual(self.r.stamps_per_tau, 555)
def test_pending_rewards_get_sets(self):
self.assertEqual(self.r.get_pending_rewards(), 0)
self.r.set_pending_rewards(1000)
self.assertEqual(self.r.get_pending_rewards(), 1000)
def test_add_pending_rewards(self):
block = random_txs.random_block()
total = 0
for tx in block.subBlocks[0].transactions:
total += tx.stampsUsed
expected = ContractingDecimal(total / 100_000)
self.assertEqual(self.r.get_pending_rewards(), 0)
self.r.add_pending_rewards(block.subBlocks[0])
self.assertEqual(self.r.get_pending_rewards(), expected)
def test_reward_ratio_works(self):
self.assertEqual(self.r.reward_ratio, [0.5, 0.5, 0, 0])
def test_issue_rewards_works(self):
self.r.set_pending_rewards(1000)
self.r.issue_rewards()
currency_contract = self.client.get_contract('currency')
self.r.add_to_balance('raghu', 1000)
self.r.add_to_balance('steve', 10000)
self.assertEqual(
currency_contract.quick_read(variable='balances', key='stu'),
ContractingDecimal(166.66666666666666))
self.assertEqual(
currency_contract.quick_read(variable='balances', key='raghu'),
ContractingDecimal(1166.66666666666666))
self.assertEqual(
currency_contract.quick_read(variable='balances', key='steve'),
ContractingDecimal(10166.66666666666666))
self.assertEqual(
currency_contract.quick_read(variable='balances', key='tejas'),
250)
self.assertEqual(
currency_contract.quick_read(variable='balances', key='alex'), 250)
self.assertEqual(self.r.get_pending_rewards(), 0)
def setUp(self):
self.loop = asyncio.get_event_loop()
self.ctx = zmq.asyncio.Context()
self.client = ContractingClient()
def setUp(self):
self.client = ContractingClient()
self.rewards = rewards.RewardManager()
import unittest
from contracting.client import ContractingClient
from exercises.lamdem_blog_sample import my_token
client = ContractingClient()
# SC's get added to DB with each call
# You should either verify before submitting, or wrapping in a try/catch block
running_contracts = client.get_contracts()
if 'my_token' not in running_contracts:
client.submit(my_token)
# Running into errors when loading it like this.
# I think it might be because of extra headers, and imports
# with open('../exercises/lamdem_blog_sample.py') as f:
# code = f.read()
# client.submit(code, name='my_token')
class MyTestCase(unittest.TestCase):
def test_supply(self):
my_token = client.get_contract('my_token')
self.assertEqual(my_token.quick_read('S', 'me'), 50)
def test_transfer(self):
# set transaction sender
client.signer = 'me'
# get contract reference
my_token = client.get_contract('my_token')
