def test_reward(testerchain, agency, token_economics):
testerchain.time_travel(hours=1)
token_agent, staking_agent, _policy_agent = agency
origin = testerchain.etherbase_account
ursula = testerchain.ursula_account(0)
# Prepare one staker
_txhash = token_agent.transfer(
amount=token_economics.minimum_allowed_locked,
target_address=ursula,
sender_address=origin)
testerchain.transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD, account=ursula)
testerchain.transacting_power.activate()
_txhash = token_agent.approve_transfer(
amount=token_economics.minimum_allowed_locked,
target_address=staking_agent.contract_address,
sender_address=ursula)
_txhash = staking_agent.deposit_tokens(
amount=token_economics.minimum_allowed_locked,
lock_periods=100 * token_economics.maximum_rewarded_periods,
sender_address=ursula)
_txhash = staking_agent.set_worker(staker_address=ursula,
worker_address=ursula)
# Get a reward for one period
_txhash = staking_agent.confirm_activity(worker_address=ursula)
testerchain.time_travel(periods=1)
_txhash = staking_agent.confirm_activity(worker_address=ursula)
assert staking_agent.calculate_staking_reward(staker_address=ursula) == 0
testerchain.time_travel(periods=1)
_txhash = staking_agent.confirm_activity(worker_address=ursula)
contract_reward = staking_agent.calculate_staking_reward(
staker_address=ursula)
calculations_reward = token_economics.cumulative_rewards_at_period(1)
error = (contract_reward - calculations_reward) / calculations_reward
assert error > 0
assert error < MAX_ERROR
# Get a reward for other periods
for i in range(1, MAX_PERIODS):
testerchain.time_travel(periods=1)
_txhash = staking_agent.confirm_activity(worker_address=ursula)
contract_reward = staking_agent.calculate_staking_reward(
staker_address=ursula)
calculations_reward = token_economics.cumulative_rewards_at_period(i +
1)
next_error = (contract_reward -
calculations_reward) / calculations_reward
assert next_error > 0
assert next_error < error
error = next_error
def test_withdraw_compensation(testerchain, agency, token_economics,
test_registry):
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
bidder = testerchain.client.accounts[2]
tpower = TransactingPower(account=bidder,
signer=Web3Signer(testerchain.client))
balance = testerchain.w3.eth.getBalance(bidder)
receipt = agent.withdraw_compensation(transacting_power=tpower)
assert receipt['status'] == 1
assert testerchain.w3.eth.getBalance(bidder) > balance
assert agent.get_available_compensation(
testerchain.client.accounts[2]) == 0
def test_approve_transfer(agent, application_economics):
testerchain = agent.blockchain
deployer, someone, *everybody_else = testerchain.client.accounts
tpower = TransactingPower(account=someone, signer=Web3Signer(testerchain.client))
# Approve
receipt = agent.approve_transfer(amount=application_economics.min_authorization,
spender_address=agent.contract_address,
transacting_power=tpower)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
def bootstrap_network(cls) -> 'TesterBlockchain':
"""For use with metric testing scripts"""
testerchain = cls(compiler=SolidityCompiler())
power = TransactingPower(blockchain=testerchain,
password=INSECURE_DEVELOPMENT_PASSWORD,
account=testerchain.etherbase_account)
power.activate()
testerchain.transacting_power = power
origin = testerchain.client.etherbase
deployer = DeployerActor(blockchain=testerchain,
deployer_address=origin,
bare=True)
secrets = dict()
for deployer_class in deployer.upgradeable_deployer_classes:
secrets[
deployer_class.contract_name] = INSECURE_DEVELOPMENT_PASSWORD
_receipts = deployer.deploy_network_contracts(secrets=secrets,
interactive=False)
return testerchain
def stakers(testerchain, agency, token_economics, test_registry):
token_agent, _staking_agent, _policy_agent = agency
blockchain = token_agent.blockchain
# Mock Powerup consumption (Deployer)
blockchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
account=blockchain.etherbase_account)
blockchain.transacting_power.activate()
token_airdrop(origin=blockchain.etherbase_account,
addresses=blockchain.stakers_accounts,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
stakers = list()
for index, account in enumerate(blockchain.stakers_accounts):
staker = Staker(is_me=True, checksum_address=account, registry=test_registry)
# Mock TransactingPower consumption
staker.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD, account=account)
staker.transacting_power.activate()
amount = MIN_STAKE_FOR_TESTS + random.randrange(BONUS_TOKENS_FOR_TESTS)
# for a random lock duration
min_locktime, max_locktime = token_economics.minimum_locked_periods, token_economics.maximum_rewarded_periods
periods = random.randint(min_locktime, max_locktime)
staker.initialize_stake(amount=amount, lock_periods=periods)
# We assume that the staker knows in advance the account of her worker
worker_address = blockchain.ursula_account(index)
staker.set_worker(worker_address=worker_address)
stakers.append(staker)
# Stake starts next period (or else signature validation will fail)
blockchain.time_travel(periods=1)
yield stakers
def bootstrap_network(
cls,
registry: Optional[BaseContractRegistry] = None,
economics: BaseEconomics = None
) -> Tuple['TesterBlockchain', 'InMemoryContractRegistry']:
"""For use with metric testing scripts"""
if registry is None:
registry = InMemoryContractRegistry()
testerchain = cls()
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=testerchain.provider_uri):
BlockchainInterfaceFactory.register_interface(
interface=testerchain)
power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
account=testerchain.etherbase_account)
power.activate()
testerchain.transacting_power = power
origin = testerchain.client.etherbase
admin = ContractAdministrator(deployer_address=origin,
registry=registry,
economics=economics
or cls.DEFAULT_ECONOMICS)
gas_limit = None # TODO: Gas management - #842
for deployer_class in admin.primary_deployer_classes:
if deployer_class is StakingEscrowDeployer:
admin.deploy_contract(
contract_name=deployer_class.contract_name,
gas_limit=gas_limit,
deployment_mode=INIT)
else:
admin.deploy_contract(
contract_name=deployer_class.contract_name,
gas_limit=gas_limit)
admin.deploy_contract(
contract_name=StakingEscrowDeployer.contract_name,
gas_limit=gas_limit)
return testerchain, registry
def test_reward(testerchain, agency, token_economics):
testerchain.time_travel(hours=1)
token_agent, staking_agent, _policy_agent = agency
origin = testerchain.etherbase_account
ursula = testerchain.ursula_account(0)
origin_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=origin)
ursula_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=ursula)
# Prepare one staker
_txhash = token_agent.transfer(amount=token_economics.minimum_allowed_locked,
target_address=ursula,
transacting_power=origin_tpower)
_txhash = token_agent.approve_transfer(amount=token_economics.minimum_allowed_locked,
spender_address=staking_agent.contract_address,
transacting_power=ursula_tpower)
_txhash = staking_agent.deposit_tokens(amount=token_economics.minimum_allowed_locked,
lock_periods=100 * token_economics.maximum_rewarded_periods,
transacting_power=ursula_tpower,
staker_address=ursula)
_txhash = staking_agent.bond_worker(staker_address=ursula, worker_address=ursula)
_txhash = staking_agent.set_restaking(staker_address=ursula, value=False)
_txhash = staking_agent.commit_to_next_period(worker_address=ursula)
testerchain.time_travel(periods=1)
_txhash = staking_agent.commit_to_next_period(worker_address=ursula)
assert staking_agent.calculate_staking_reward(staker_address=ursula) == 0
# Get a reward
switch = token_economics.first_phase_final_period()
for i in range(1, switch + MAX_PERIODS_SECOND_PHASE):
testerchain.time_travel(periods=1)
_txhash = staking_agent.commit_to_next_period(transacting_power=ursula_tpower)
contract_reward = staking_agent.calculate_staking_reward(staker_address=ursula)
calculations_reward = token_economics.cumulative_rewards_at_period(i)
error = abs((contract_reward - calculations_reward) / calculations_reward)
if i <= switch:
assert error < MAX_ERROR_FIRST_PHASE
else:
assert error < MAX_ERROR_SECOND_PHASE
def test_bidding(testerchain, agency, token_economics, test_registry):
small_bid = token_economics.worklock_min_allowed_bid
big_bid = 5 * token_economics.worklock_min_allowed_bid
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
# Round 1
for multiplier, bidder in enumerate(testerchain.client.accounts[:11],
start=1):
bid = big_bid * multiplier
tpower = TransactingPower(account=bidder,
signer=Web3Signer(testerchain.client))
receipt = agent.bid(transacting_power=tpower, value=bid)
assert receipt['status'] == 1
# Round 2
for multiplier, bidder in enumerate(testerchain.client.accounts[:11],
start=1):
bid = (small_bid * 2) * multiplier
tpower = TransactingPower(account=bidder,
signer=Web3Signer(testerchain.client))
receipt = agent.bid(transacting_power=tpower, value=bid)
assert receipt['status'] == 1
def test_confirm_activity(agency, testerchain):
_token_agent, staking_agent, _policy_agent = agency
staker_account, worker_account, *other = testerchain.unassigned_accounts
# Mock Powerup consumption (Ursula-Worker)
testerchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
account=worker_account)
testerchain.transacting_power.activate()
receipt = staking_agent.confirm_activity(worker_address=worker_account)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == staking_agent.contract_address
def test_cancel_bid(testerchain, agency, token_economics, test_registry):
bidder = testerchain.client.accounts[1]
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
assert agent.get_deposited_eth(bidder) # Bid
receipt = agent.cancel_bid(transacting_power=tpower) # Cancel
assert receipt['status'] == 1
assert not agent.get_deposited_eth(bidder) # No more bid
# Can't cancel a bid twice in a row
with pytest.raises((TransactionFailed, ValueError)):
_receipt = agent.cancel_bid(transacting_power=tpower)
def software_stakeholder(testerchain, agency, stakeholder_config_file_location, test_registry):
token_agent, staking_agent, policy_agent = agency
# Setup
path = stakeholder_config_file_location
if os.path.exists(path):
os.remove(path)
# 0xaAa482c790b4301bE18D75A0D1B11B2ACBEF798B
stakeholder_private_key = '255f64a948eeb1595b8a2d1e76740f4683eca1c8f1433d13293db9b6e27676cc'
address = testerchain.provider.ethereum_tester.add_account(private_key=stakeholder_private_key,
password=INSECURE_DEVELOPMENT_PASSWORD)
testerchain.provider.ethereum_tester.unlock_account(account=address, password=INSECURE_DEVELOPMENT_PASSWORD)
tx = {'to': address,
'from': testerchain.etherbase_account,
'value': Web3.toWei('1', 'ether')}
txhash = testerchain.client.w3.eth.sendTransaction(tx)
_receipt = testerchain.wait_for_receipt(txhash)
# Mock TransactingPower consumption (Etherbase)
transacting_power = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client),
password=INSECURE_DEVELOPMENT_PASSWORD)
transacting_power.activate()
token_agent.transfer(amount=NU(200_000, 'NU').to_nunits(),
sender_address=testerchain.etherbase_account,
target_address=address)
# Create stakeholder from on-chain values given accounts over a web3 provider
stakeholder = StakeHolder(registry=test_registry, initial_address=address)
# Teardown
yield stakeholder
if os.path.exists(path):
os.remove(path)
def __init__(self,
registry: BaseContractRegistry,
deployer_address: str = None,
client_password: str = None,
economics: TokenEconomics = None):
"""
Note: super() is not called here to avoid setting the token agent.
TODO: Review this logic ^^ "bare mode".
"""
self.log = Logger("Deployment-Actor")
self.deployer_address = deployer_address
self.checksum_address = self.deployer_address
self.economics = economics or StandardTokenEconomics()
self.registry = registry
self.preallocation_escrow_deployers = dict()
self.deployers = {d.contract_name: d for d in self.deployer_classes}
self.transacting_power = TransactingPower(password=client_password,
account=deployer_address)
self.transacting_power.activate()
def test_reward(testerchain, agency, token_economics, test_registry):
testerchain.time_travel(hours=1)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
_policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
origin = testerchain.etherbase_account
ursula1 = testerchain.ursula_account(0)
ursula2 = testerchain.ursula_account(1)
origin_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=origin)
ursula1_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=ursula1)
ursula2_tpower = TransactingPower(signer=Web3Signer(client=testerchain.client), account=ursula2)
# Prepare one staker
prepare_staker(origin_tpower, staking_agent, token_agent, token_economics, ursula1, ursula1_tpower, token_economics.minimum_allowed_locked)
prepare_staker(origin_tpower, staking_agent, token_agent, token_economics, ursula2, ursula2_tpower,
token_economics.minimum_allowed_locked * 3) # 3x min
ursulas_tpowers = [ursula1_tpower, ursula2_tpower]
commit_to_next_period(staking_agent, ursulas_tpowers)
testerchain.time_travel(periods=1)
commit_to_next_period(staking_agent, ursulas_tpowers)
assert staking_agent.calculate_staking_reward(staker_address=ursula1) == 0
assert staking_agent.calculate_staking_reward(staker_address=ursula2) == 0
# Get a reward
switch = token_economics.first_phase_final_period()
for i in range(1, switch + MAX_PERIODS_SECOND_PHASE):
testerchain.time_travel(periods=1)
commit_to_next_period(staking_agent, ursulas_tpowers)
ursula1_rewards = staking_agent.calculate_staking_reward(staker_address=ursula1)
ursula2_rewards = staking_agent.calculate_staking_reward(staker_address=ursula2)
calculations_reward = token_economics.cumulative_rewards_at_period(i)
error = abs((ursula1_rewards + ursula2_rewards - calculations_reward) / calculations_reward)
if i <= switch:
assert error < MAX_ERROR_FIRST_PHASE
else:
assert error < MAX_ERROR_SECOND_PHASE
def test_rapid_deployment(token_economics):
compiler = SolidityCompiler()
allocation_registry = InMemoryAllocationRegistry()
blockchain = _TesterBlockchain(eth_airdrop=False,
test_accounts=4,
compiler=compiler)
# TODO: #1092 - TransactingPower
blockchain.transacting_power = TransactingPower(blockchain=blockchain,
password=INSECURE_DEVELOPMENT_PASSWORD,
account=blockchain.etherbase_account)
blockchain.transacting_power.activate()
deployer_address = blockchain.etherbase_account
deployer = DeployerActor(blockchain=blockchain, deployer_address=deployer_address)
secrets = dict()
for deployer_class in deployer.upgradeable_deployer_classes:
secrets[deployer_class.contract_name] = INSECURE_DEVELOPMENT_PASSWORD
deployer.deploy_network_contracts(secrets=secrets, emitter=StdoutEmitter())
all_yall = blockchain.unassigned_accounts
# Start with some hard-coded cases...
allocation_data = [{'address': all_yall[1],
'amount': token_economics.maximum_allowed_locked,
'duration': ONE_YEAR_IN_SECONDS},
{'address': all_yall[2],
'amount': token_economics.minimum_allowed_locked,
'duration': ONE_YEAR_IN_SECONDS*2},
{'address': all_yall[3],
'amount': token_economics.minimum_allowed_locked*100,
'duration': ONE_YEAR_IN_SECONDS*3}
]
# Pile on the rest
for _ in range(NUMBER_OF_ALLOCATIONS_IN_TESTS - len(allocation_data)):
random_password = ''.join(random.SystemRandom().choice(string.ascii_uppercase+string.digits) for _ in range(16))
acct = w3.eth.account.create(random_password)
beneficiary_address = acct.address
amount = random.randint(token_economics.minimum_allowed_locked, token_economics.maximum_allowed_locked)
duration = random.randint(token_economics.minimum_locked_periods*ONE_YEAR_IN_SECONDS,
(token_economics.maximum_locked_periods*ONE_YEAR_IN_SECONDS)*3)
random_allocation = {'address': beneficiary_address, 'amount': amount, 'duration': duration}
allocation_data.append(random_allocation)
deployer.deploy_beneficiary_contracts(allocations=allocation_data, allocation_registry=allocation_registry)
def stakers(testerchain, agency, token_economics, test_registry,
deployer_transacting_power):
token_agent = ContractAgency.get_agent(NucypherTokenAgent,
registry=test_registry)
blockchain = token_agent.blockchain
token_airdrop(transacting_power=deployer_transacting_power,
addresses=blockchain.stakers_accounts,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
stakers = list()
for index, account in enumerate(blockchain.stakers_accounts):
tpower = TransactingPower(account=account,
signer=Web3Signer(testerchain.client))
tpower.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
staker = Staker(transacting_power=tpower,
domain=TEMPORARY_DOMAIN,
registry=test_registry)
amount = MIN_STAKE_FOR_TESTS + random.randrange(BONUS_TOKENS_FOR_TESTS)
# for a random lock duration
min_locktime, max_locktime = token_economics.minimum_locked_periods, token_economics.maximum_rewarded_periods
periods = random.randint(min_locktime, max_locktime)
staker.initialize_stake(amount=amount, lock_periods=periods)
# We assume that the staker knows in advance the account of her worker
worker_address = blockchain.ursula_account(index)
staker.bond_worker(worker_address=worker_address)
stakers.append(staker)
# Stake starts next period
blockchain.time_travel(periods=1)
yield stakers
def test_verify_correctness(testerchain, agency, token_economics,
test_registry):
agent = ContractAgency.get_agent(
WorkLockAgent, registry=test_registry) # type: WorkLockAgent
caller = testerchain.client.accounts[0]
tpower = TransactingPower(account=caller,
signer=Web3Signer(testerchain.client))
assert not agent.bidders_checked()
assert agent.estimate_verifying_correctness(gas_limit=100000) == 10
receipt = agent.verify_bidding_correctness(transacting_power=tpower,
gas_limit=100000)
assert receipt['status'] == 1
assert agent.bidders_checked()
assert agent.is_claiming_available()
def test_character_transacting_power_signing(testerchain, agency,
test_registry):
# Pretend to be a character.
eth_address = testerchain.etherbase_account
signer = Character(is_me=True,
eth_provider_uri=MOCK_ETH_PROVIDER_URI,
registry=test_registry,
checksum_address=eth_address)
# Manually consume the power up
transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(testerchain.client),
account=eth_address)
signer._crypto_power.consume_power_up(transacting_power)
# Retrieve the power up
power = signer._crypto_power.power_ups(TransactingPower)
assert power == transacting_power
# Sign Message
data_to_sign = b'Premium Select Luxury Pencil Holder'
signature = power.sign_message(message=data_to_sign)
is_verified = verify_eip_191(address=eth_address,
message=data_to_sign,
signature=signature)
assert is_verified is True
# Sign Transaction
transaction_dict = {
'nonce': testerchain.client.w3.eth.getTransactionCount(eth_address),
'gasPrice': testerchain.client.w3.eth.gasPrice,
'gas': 100000,
'from': eth_address,
'to': testerchain.unassigned_accounts[1],
'value': 1,
'data': b''
}
signed_transaction = power.sign_transaction(
transaction_dict=transaction_dict)
# Demonstrate that the transaction is valid RLP encoded.
restored_transaction = Transaction.from_bytes(
serialized_bytes=signed_transaction)
restored_dict = restored_transaction.as_dict()
assert to_checksum_address(restored_dict['to']) == transaction_dict['to']
def test_force_refund(testerchain, agency, token_economics, test_registry):
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
caller = testerchain.client.accounts[0]
tpower = TransactingPower(account=caller,
signer=Web3Signer(testerchain.client))
with pytest.raises(BlockchainInterface.InterfaceError):
_receipt = agent.verify_bidding_correctness(transacting_power=tpower,
gas_limit=100000)
receipt = agent.force_refund(transacting_power=tpower,
addresses=testerchain.client.accounts[2:11])
assert receipt['status'] == 1
assert agent.get_available_compensation(testerchain.client.accounts[2]) > 0
def test_rapid_deployment(token_economics, test_registry, tmpdir, get_random_checksum_address):
compiler = SolidityCompiler()
blockchain = _TesterBlockchain(eth_airdrop=False,
test_accounts=4,
compiler=compiler)
# TODO: #1092 - TransactingPower
blockchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
account=blockchain.etherbase_account)
blockchain.transacting_power.activate()
deployer_address = blockchain.etherbase_account
administrator = ContractAdministrator(deployer_address=deployer_address,
registry=test_registry)
administrator.deploy_network_contracts(emitter=StdoutEmitter(), interactive=False)
all_yall = blockchain.unassigned_accounts
# Start with some hard-coded cases...
allocation_data = [{'checksum_address': all_yall[1],
'amount': token_economics.maximum_allowed_locked,
'lock_periods': token_economics.minimum_locked_periods},
{'checksum_address': all_yall[2],
'amount': token_economics.minimum_allowed_locked,
'lock_periods': token_economics.minimum_locked_periods},
{'checksum_address': all_yall[3],
'amount': token_economics.minimum_allowed_locked*100,
'lock_periods': token_economics.minimum_locked_periods},
]
# Pile on the rest
for _ in range(NUMBER_OF_ALLOCATIONS_IN_TESTS - len(allocation_data)):
checksum_address = get_random_checksum_address()
amount = random.randint(token_economics.minimum_allowed_locked, token_economics.maximum_allowed_locked)
duration = random.randint(token_economics.minimum_locked_periods, token_economics.maximum_rewarded_periods)
random_allocation = {'checksum_address': checksum_address, 'amount': amount, 'lock_periods': duration}
allocation_data.append(random_allocation)
filepath = tmpdir / "allocations.json"
with open(filepath, 'w') as f:
json.dump(allocation_data, f)
administrator.batch_deposits(allocation_data_filepath=str(filepath), interactive=False)
minimum, default, maximum = 10, 20, 30
administrator.set_fee_rate_range(minimum, default, maximum)
def bootstrap_network(
cls,
economics: BaseEconomics = None
) -> Tuple['TesterBlockchain', 'InMemoryContractRegistry']:
"""For use with metric testing scripts"""
registry = InMemoryContractRegistry()
testerchain = cls(compiler=SolidityCompiler())
BlockchainInterfaceFactory.register_interface(testerchain)
power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
account=testerchain.etherbase_account)
power.activate()
testerchain.transacting_power = power
origin = testerchain.client.etherbase
deployer = ContractAdministrator(deployer_address=origin,
registry=registry,
economics=economics
or cls._default_token_economics,
staking_escrow_test_mode=True)
_receipts = deployer.deploy_network_contracts(interactive=False)
return testerchain, registry
def test_transacting_power_sign_agent_transaction(testerchain, agency):
token_agent = NucypherTokenAgent(blockchain=testerchain)
contract_function = token_agent.contract.functions.approve(testerchain.etherbase_account, 100)
payload = {'chainId': int(testerchain.client.net_version),
'nonce': testerchain.client.w3.eth.getTransactionCount(testerchain.etherbase_account),
'from': testerchain.etherbase_account,
'gasPrice': testerchain.client.gas_price}
unsigned_transaction = contract_function.buildTransaction(payload)
# Sign with Transacting Power
transacting_power = TransactingPower(blockchain=testerchain,
password=INSECURE_DEVELOPMENT_PASSWORD,
account=testerchain.etherbase_account)
transacting_power.activate()
signed_raw_transaction = transacting_power.sign_transaction(unsigned_transaction)
# Demonstrate that the transaction is valid RLP encoded.
restored_transaction = Transaction.from_bytes(serialized_bytes=signed_raw_transaction)
restored_dict = restored_transaction.as_dict()
assert to_checksum_address(restored_dict['to']) == unsigned_transaction['to']
def test_create_bidder(testerchain, test_registry, agency, token_economics):
bidder_address = testerchain.unassigned_accounts[0]
tpower = TransactingPower(account=bidder_address,
signer=Web3Signer(testerchain.client))
bidder = Bidder(domain=TEMPORARY_DOMAIN,
registry=test_registry,
transacting_power=tpower)
assert bidder.checksum_address == bidder_address
assert bidder.registry == test_registry
assert not bidder.get_deposited_eth
assert not bidder.completed_work
assert not bidder.remaining_work
assert not bidder.refunded_work
def staker(testerchain, agency, test_registry, deployer_transacting_power):
token_agent = ContractAgency.get_agent(NucypherTokenAgent,
registry=test_registry)
origin, staker_account, *everybody_else = testerchain.client.accounts
staker_power = TransactingPower(account=staker_account,
signer=Web3Signer(testerchain.client))
token_airdrop(token_agent=token_agent,
transacting_power=deployer_transacting_power,
addresses=[staker_account],
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
staker = Staker(domain=TEMPORARY_DOMAIN,
transacting_power=staker_power,
registry=test_registry)
return staker
def test_cancel_after_bidding(testerchain, agency, token_economics, test_registry):
# Wait until the bidding window closes...
testerchain.time_travel(seconds=token_economics.bidding_duration+1)
bidder = testerchain.client.accounts[0]
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
assert agent.get_deposited_eth(bidder) # Bid
receipt = agent.cancel_bid(transacting_power=tpower) # Cancel
assert receipt['status'] == 1
assert not agent.get_deposited_eth(bidder) # No more bid
def test_transacting_power_sign_agent_transaction(testerchain, agency,
test_registry):
agent = ContractAgency.get_agent(PREApplicationAgent,
registry=test_registry)
contract_function = agent.contract.functions.confirmOperatorAddress()
payload = {
'chainId':
int(testerchain.client.chain_id),
'nonce':
testerchain.client.w3.eth.getTransactionCount(
testerchain.etherbase_account),
'from':
testerchain.etherbase_account,
'gasPrice':
testerchain.client.gas_price,
'gas':
500_000
}
unsigned_transaction = contract_function.buildTransaction(payload)
# Sign with Transacting Power
transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(testerchain.client),
account=testerchain.etherbase_account)
signed_raw_transaction = transacting_power.sign_transaction(
unsigned_transaction)
# Demonstrate that the transaction is valid RLP encoded.
restored_transaction = Transaction.from_bytes(
serialized_bytes=signed_raw_transaction)
restored_dict = restored_transaction.as_dict()
assert to_checksum_address(
restored_dict['to']) == unsigned_transaction['to']
def _make_testerchain():
"""
https://github.com/ethereum/eth-tester # available-backends
"""
# Create the blockchain
testerchain = TesterBlockchain(eth_airdrop=True, free_transactions=True)
# Mock TransactingPower Consumption (Deployer)
testerchain.deployer_address = testerchain.etherbase_account
testerchain.transacting_power = TransactingPower(
blockchain=testerchain,
password=INSECURE_DEVELOPMENT_PASSWORD,
account=testerchain.deployer_address)
testerchain.transacting_power.activate()
return testerchain
def test_transfer(agent, application_economics):
testerchain = agent.blockchain
origin, someone, *everybody_else = testerchain.client.accounts
tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
old_balance = agent.get_balance(someone)
receipt = agent.transfer(amount=application_economics.min_authorization,
target_address=someone,
transacting_power=tpower)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
new_balance = agent.get_balance(someone)
assert new_balance == old_balance + application_economics.min_authorization
def test_calculate_refund(testerchain, agency, policy_meta):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
staker = policy_meta.addresses[-1]
worker = staking_agent.get_worker_from_staker(staker)
# Mock Powerup consumption (Ursula-Worker)
testerchain.transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD, account=worker)
testerchain.transacting_power.activate()
testerchain.time_travel(hours=9)
_receipt = staking_agent.confirm_activity(worker_address=worker)
# Mock Powerup consumption (Alice)
testerchain.transacting_power = TransactingPower(
password=INSECURE_DEVELOPMENT_PASSWORD,
account=testerchain.alice_account)
testerchain.transacting_power.activate()
receipt = agent.calculate_refund(policy_id=policy_meta.policy_id,
author_address=policy_meta.author)
assert receipt['status'] == 1, "Transaction Rejected"
def test_claim_before_checking(testerchain, agency, token_economics, test_registry):
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
bidder = testerchain.client.accounts[2]
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
assert not agent.is_claiming_available()
with pytest.raises(TransactionFailed):
_receipt = agent.claim(transacting_power=tpower)
# Wait until the cancellation window closes...
testerchain.time_travel(seconds=token_economics.cancellation_end_date+1)
assert not agent.is_claiming_available()
with pytest.raises(TransactionFailed):
_receipt = agent.claim(transacting_power=tpower)
def idle_staker(testerchain, agency, test_registry):
token_agent = ContractAgency.get_agent(NucypherTokenAgent,
registry=test_registry)
idle_staker_account = testerchain.unassigned_accounts[-2]
transacting_power = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client))
token_airdrop(transacting_power=transacting_power,
addresses=[idle_staker_account],
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
# Prepare idle staker
idle_staker = Staker(transacting_power=transacting_power,
domain=TEMPORARY_DOMAIN,
blockchain=testerchain)
yield idle_staker
