def blockchain_ursulas(three_agents, ursula_decentralized_test_config):
token_agent, miner_agent, policy_agent = three_agents
etherbase, alice, bob, *all_yall = token_agent.blockchain.interface.w3.eth.accounts
ursula_addresses = all_yall[:NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK]
token_airdrop(origin=etherbase,
addresses=ursula_addresses,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
# Leave out the last Ursula for manual stake testing
*all_but_the_last_ursula, the_last_ursula = ursula_addresses
_ursulas = make_decentralized_ursulas(ursula_config=ursula_decentralized_test_config,
ether_addresses=all_but_the_last_ursula,
stake=True)
# This one is not going to stake
_non_staking_ursula = make_decentralized_ursulas(ursula_config=ursula_decentralized_test_config,
ether_addresses=[the_last_ursula],
stake=False)
_ursulas.extend(_non_staking_ursula)
token_agent.blockchain.time_travel(periods=1)
yield _ursulas
def blockchain_ursulas(three_agents, ursula_decentralized_test_config):
token_agent, miner_agent, policy_agent = three_agents
blockchain = token_agent.blockchain
token_airdrop(origin=blockchain.etherbase_account,
addresses=blockchain.ursulas_accounts,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
# Leave out the last Ursula for manual stake testing
*all_but_the_last_ursula, the_last_ursula = blockchain.ursulas_accounts
_ursulas = make_decentralized_ursulas(
ursula_config=ursula_decentralized_test_config,
ether_addresses=all_but_the_last_ursula,
stake=True)
# This one is not going to stake
_non_staking_ursula = make_decentralized_ursulas(
ursula_config=ursula_decentralized_test_config,
ether_addresses=[the_last_ursula],
stake=False)
_ursulas.extend(_non_staking_ursula)
blockchain.time_travel(periods=1)
yield _ursulas
def blockchain_ursulas(three_agents, ursula_decentralized_test_config):
token_agent, _miner_agent, _policy_agent = three_agents
blockchain = token_agent.blockchain
token_airdrop(origin=blockchain.etherbase_account,
addresses=blockchain.ursulas_accounts,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
# Leave out the last Ursula for manual stake testing
*all_but_the_last_ursula, the_last_ursula = blockchain.ursulas_accounts
_ursulas = make_decentralized_ursulas(
ursula_config=ursula_decentralized_test_config,
ether_addresses=all_but_the_last_ursula,
stake=True)
# Stake starts next period (or else signature validation will fail)
blockchain.time_travel(periods=1)
# Bootstrap the network
for ursula_to_teach in _ursulas:
for ursula_to_learn_about in _ursulas:
ursula_to_teach.remember_node(ursula_to_learn_about)
# TODO: #1035 - Move non-staking Ursulas to a new fixture
# This one is not going to stake
_non_staking_ursula = make_decentralized_ursulas(
ursula_config=ursula_decentralized_test_config,
ether_addresses=[the_last_ursula],
stake=False)
_ursulas.extend(_non_staking_ursula)
yield _ursulas
def test_staker_manages_winding_down(testerchain, test_registry, staker,
token_economics,
ursula_decentralized_test_config):
# Get worker
ursula = make_decentralized_ursulas(
ursula_config=ursula_decentralized_test_config,
stakers_addresses=[staker.checksum_address],
workers_addresses=[staker.worker_address],
confirm_activity=False,
registry=test_registry).pop()
# Enable winding down
testerchain.time_travel(periods=1)
base_duration = token_economics.minimum_locked_periods + 4
receipt = staker.enable_winding_down()
assert receipt['status'] == 1
assert staker.locked_tokens(base_duration) != 0
assert staker.locked_tokens(base_duration + 1) == 0
ursula.confirm_activity()
assert staker.locked_tokens(base_duration) != 0
assert staker.locked_tokens(base_duration + 1) == 0
# Disable winding down
testerchain.time_travel(periods=1)
receipt = staker.disable_winding_down()
assert receipt['status'] == 1
assert staker.locked_tokens(base_duration - 1) != 0
assert staker.locked_tokens(base_duration) == 0
ursula.confirm_activity()
assert staker.locked_tokens(base_duration - 1) != 0
assert staker.locked_tokens(base_duration) == 0
def test_stakers_bond_to_ursulas(testerchain, test_registry, stakers, ursula_decentralized_test_config):
ursulas = make_decentralized_ursulas(ursula_config=ursula_decentralized_test_config,
stakers_addresses=testerchain.stakers_accounts,
workers_addresses=testerchain.ursulas_accounts,
confirm_activity=False)
assert len(ursulas) == len(stakers)
for ursula in ursulas:
ursula.validate_worker(registry=test_registry)
assert ursula.verified_worker
def test_worker_auto_confirmations(testerchain, test_registry, staker, agency,
token_economics,
ursula_decentralized_test_config):
# Mock Powerup consumption (Ursula-Worker)
testerchain.transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD,
account=staker.checksum_address)
testerchain.transacting_power.activate()
staker.initialize_stake(
amount=NU(token_economics.minimum_allowed_locked, 'NuNit'),
lock_periods=int(token_economics.minimum_locked_periods))
# Get an unused address and create a new worker
worker_address = testerchain.unassigned_accounts[-1]
# Control time
clock = Clock()
WorkTracker.CLOCK = clock
# Bond the Worker and Staker
staker.set_worker(worker_address=worker_address)
# Make the Worker
ursula = make_decentralized_ursulas(
ursula_config=ursula_decentralized_test_config,
stakers_addresses=[staker.checksum_address],
workers_addresses=[worker_address],
confirm_activity=False,
registry=test_registry).pop()
def start():
# Start running the worker
start_pytest_ursula_services(ursula=ursula)
ursula.work_tracker.start()
def time_travel(_):
testerchain.time_travel(periods=1)
clock.advance(WorkTracker.REFRESH_RATE + 1)
def verify(_):
# Verify that periods were confirmed on-chain automatically
last_active_period = staker.staking_agent.get_last_active_period(
staker_address=staker.checksum_address)
current_period = staker.staking_agent.get_current_period()
assert (last_active_period - current_period) == 1
# Run the callbacks
d = threads.deferToThread(start)
for i in range(5):
d.addCallback(time_travel)
d.addCallback(verify)
yield d
def test_staker_collects_staking_reward(testerchain, test_registry, staker,
blockchain_ursulas, agency,
token_economics,
ursula_decentralized_test_config):
token_agent, staking_agent, policy_agent = agency
# Capture the current token balance of the staker
initial_balance = staker.token_balance
assert token_agent.get_balance(staker.checksum_address) == initial_balance
# Mock Powerup consumption (Ursula-Worker)
testerchain.transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD,
account=staker.checksum_address)
testerchain.transacting_power.activate()
staker.initialize_stake(
amount=NU(token_economics.minimum_allowed_locked,
'NuNit'), # Lock the minimum amount of tokens
lock_periods=int(token_economics.minimum_locked_periods)
) # ... for the fewest number of periods
# Get an unused address for a new worker
worker_address = testerchain.unassigned_accounts[-1]
staker.set_worker(worker_address=worker_address)
# Create this worker and bond it with the staker
ursula = make_decentralized_ursulas(
ursula_config=ursula_decentralized_test_config,
stakers_addresses=[staker.checksum_address],
workers_addresses=[worker_address],
confirm_activity=False,
registry=test_registry).pop()
# ...wait out the lock period...
for _ in range(token_economics.minimum_locked_periods):
testerchain.time_travel(periods=1)
ursula.confirm_activity()
# ...wait more...
testerchain.time_travel(periods=2)
# Mock Powerup consumption (Ursula-Worker)
testerchain.transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD,
account=staker.checksum_address)
testerchain.transacting_power.activate()
# Profit!
staker.collect_staking_reward()
final_balance = token_agent.get_balance(staker.checksum_address)
assert final_balance > initial_balance
def blockchain_ursulas(testerchain, stakers, ursula_decentralized_test_config):
_ursulas = make_decentralized_ursulas(ursula_config=ursula_decentralized_test_config,
stakers_addresses=testerchain.stakers_accounts,
workers_addresses=testerchain.ursulas_accounts,
confirm_activity=True)
testerchain.time_travel(periods=1)
# Bootstrap the network
for ursula_to_teach in _ursulas:
for ursula_to_learn_about in _ursulas:
ursula_to_teach.remember_node(ursula_to_learn_about)
yield _ursulas
def blockchain_ursulas(testerchain, stakers, ursula_decentralized_test_config):
_ursulas = make_decentralized_ursulas(ursula_config=ursula_decentralized_test_config,
stakers_addresses=testerchain.stakers_accounts,
workers_addresses=testerchain.ursulas_accounts,
confirm_activity=True)
for u in _ursulas:
u.synchronous_query_timeout = .01 # We expect to never have to wait for content that is actually on-chain during tests.
testerchain.time_travel(periods=1)
# Bootstrap the network
for ursula_to_teach in _ursulas:
for ursula_to_learn_about in _ursulas:
ursula_to_teach.remember_node(ursula_to_learn_about)
yield _ursulas
def blockchain_ursulas(three_agents, ursula_decentralized_test_config):
token_agent, miner_agent, policy_agent = three_agents
etherbase, alice, bob, *all_yall = token_agent.blockchain.interface.w3.eth.accounts
ursula_addresses = all_yall[:DEFAULT_NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK]
token_airdrop(origin=etherbase,
addresses=ursula_addresses,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
_ursulas = make_decentralized_ursulas(ursula_config=ursula_decentralized_test_config,
ether_addresses=ursula_addresses,
stake=True)
token_agent.blockchain.time_travel(periods=1)
yield _ursulas
