def test_active_sp_holder_reward_single_acc_2hf(wallet: Wallet, not_witness_post):
post = not_witness_post
account = post["author"]
def check_reward_operation(start, stop):
rewards = []
for i in range(start, stop):
wallet.get_block(i, wait_for_block=True)
ops = wallet.get_ops_in_block(i)
rewards = [data["op"][1] for _, data in ops if data["op"][0].startswith("active")]
if rewards:
break
# Next assert also checks if legacy reward is not provided anymore
assert len(rewards) == 1, "Should be provided single active_sp_holder_reward payment."
assert rewards[0]["sp_holder"] == account, "Reward should be payed to specified user."
return Amount(rewards[0]["reward"])
apply_hardfork(wallet, 2)
validate_response(wallet.post_comment(**post), wallet.post_comment.__name__)
validate_response(wallet.vote(account, account, post["permlink"], 10000), wallet.vote.__name__)
account_before = wallet.get_account(account)
dgp_before = wallet.get_dynamic_global_properties()
assert account_before["active_sp_holders_pending_sp_reward"] == dgp_before["total_pending_sp"]
# 60 sec for testnet, one week for mainnet
reward_period_sec = int(wallet.get_config()["SCORUM_ACTIVE_SP_HOLDERS_REWARD_PERIOD"] / 1000000) # microesc -> sec
expected_cashout = to_date(account_before["last_vote_time"], tmdelta={"seconds": reward_period_sec})
actual_cashout = to_date(account_before["active_sp_holders_cashout_time"])
assert actual_cashout == expected_cashout, \
"Actual cashout time calculated incorrectly: '%s', expected '%s'" % \
(date_to_str(actual_cashout), date_to_str(expected_cashout))
blocks_to_wait = int(reward_period_sec / 3) + 1
last_block = dgp_before["head_block_number"]
reward = check_reward_operation(last_block, last_block + blocks_to_wait)
account_after = wallet.get_account(account)
assert account_before["balance"] == account_after["balance"] # until advertising is locked
assert account_before["scorumpower"] != account_after["scorumpower"]
reset_cashout = to_date(account_after["active_sp_holders_cashout_time"])
expected_cashout = to_date(account_before["active_sp_holders_cashout_time"], tmdelta={"seconds": reward_period_sec})
assert reset_cashout == expected_cashout, \
"Cashout time for active_sp_holder_reward was not reset: '%s', expected '%s'" % \
(date_to_str(reset_cashout), date_to_str(expected_cashout))
dgp_after = wallet.get_dynamic_global_properties()
assert dgp_before["total_pending_scr"] == dgp_after["total_pending_scr"] # until advertising is locked
assert Amount(dgp_after["total_pending_sp"]) == Amount("0 SP")
assert dgp_before["total_pending_sp"] != dgp_after["total_pending_sp"]
assert dgp_before["total_scorumpower"] != dgp_after["total_scorumpower"]
balance_change = Amount(account_after["scorumpower"]) - Amount(account_before["scorumpower"])
assert balance_change == reward, \
"Balance change is not equal with reward: '%s', expected '%s'" % (balance_change, reward)
last_block = dgp_after["head_block_number"]
check_reward_operation(last_block + 1, last_block + blocks_to_wait)
def test_create_post_vs_banner(wallet_3hf: Wallet, post_budget, banner_budget):
new_budget = copy(post_budget)
update_budget_time(wallet_3hf, post_budget)
validate_response(wallet_3hf.create_budget(**post_budget), wallet_3hf.create_budget.__name__)
update_budget_time(wallet_3hf, banner_budget)
validate_response(wallet_3hf.create_budget(**banner_budget), wallet_3hf.create_budget.__name__)
update_budget_balance(wallet_3hf, post_budget) # update budget params / set budget id
update_budget_balance(wallet_3hf, banner_budget) # update budget params / set budget id
assert post_budget["id"] == banner_budget["id"] # both = 0
assert len(wallet_3hf.get_budgets([post_budget['owner']], post_budget['type'])) == 1
assert len(wallet_3hf.get_budgets([banner_budget['owner']], banner_budget['type'])) == 1
budgets_summary = wallet_3hf.get_dynamic_global_properties()['advertising']
assert all(
Amount(budgets_summary[DGP_BUDGETS[b['type']]][k]) == Amount(b[v])
for k, v in DGP_PARAMS_MAP.items()
for b in [banner_budget, post_budget]
)
update_budget_time(wallet_3hf, new_budget)
new_budget.update({'uuid': gen_uid()})
validate_response(wallet_3hf.create_budget(**new_budget), wallet_3hf.create_budget.__name__)
assert len(wallet_3hf.get_budgets([post_budget['owner']], post_budget['type'])) == 2
def test_get_dynamic_global_properties(wallet: Wallet):
response = wallet.get_dynamic_global_properties()
validate_response(response, wallet.get_dynamic_global_properties.__name__, [
("head_block_number", int), "head_block_id", "current_witness", "total_supply",
"circulating_capital", "total_scorumpower", "total_pending_scr", "total_pending_sp",
"total_witness_reward_scr", "total_witness_reward_sp", "majority_version", ("current_aslot", int),
"recent_slots_filled", ("participation_count", int), ("last_irreversible_block_num", int),
"registration_pool_balance", "fund_budget_balance", "reward_pool_balance", "max_virtual_bandwidth",
"content_reward_scr_balance", "content_reward_sp_balance", ("current_reserve_ratio", int)
])
def test_create_budgets(wallet_3hf: Wallet, node, opened_budgets_same_acc, budget):
assert len(wallet_3hf.get_budgets([budget['owner']], budget['type'])) == len(opened_budgets_same_acc)
budgets_summary = wallet_3hf.get_dynamic_global_properties()['advertising']
for b in opened_budgets_same_acc:
update_budget_balance(wallet_3hf, b)
# check that sum of budgets 'param' == summary 'param' in DGP
assert all(
sum([Amount(b[v]) for b in opened_budgets_same_acc], Amount("0 SCR")) == Amount(
budgets_summary[DGP_BUDGETS[budget['type']]][k]
)
for k, v in DGP_PARAMS_MAP.items()
)
def test_active_sp_holder_reward_legacy(wallet: Wallet, post, accounts):
op_name = "active_sp_holders_reward_legacy"
validate_response(wallet.post_comment(**post), wallet.post_comment.__name__)
for acc in accounts:
validate_response(wallet.vote(acc, post["author"], post["permlink"]), wallet.vote.__name__)
last_block = wallet.get_dynamic_global_properties()["head_block_number"]
# e.g. next N blocks should be payed active_sp_holders_reward_legacy
for i in range(last_block, last_block + 5):
wallet.get_block(i, wait_for_block=True)
ops = wallet.get_ops_in_block(i)
rewards = [data["op"][1]["rewarded"] for _, data in ops if data["op"][0] == op_name][0]
assert len(rewards) == len(accounts), "Was provided unexpected amount of '%s' operations." % op_name
for acc, _ in rewards:
assert acc in accounts, "Provided payment to unexpected account: '%s'" % acc
def test_genesis_block(wallet: Wallet, genesis: Genesis):
info = wallet.get_dynamic_global_properties()
records = [
'accounts_supply', 'rewards_supply', 'registration_supply',
'founders_supply', 'steemit_bounty_accounts_supply',
'development_sp_supply', 'development_scr_supply'
]
expected_total_supply = Amount()
for r in records:
expected_total_supply = expected_total_supply + Amount(genesis[r])
assert Amount(info['total_supply']) == expected_total_supply
for account, amount in genesis.genesis_accounts:
assert wallet.get_account_scr_balance(account.name) == amount
def test_create_budget(wallet_3hf: Wallet, node, budget, start, deadline):
update_budget_time(wallet_3hf, budget, start=start, deadline=deadline + start)
budget_balance = Amount(budget["balance"])
balance_before = wallet_3hf.get_account_scr_balance(budget["owner"])
response = wallet_3hf.create_budget(**budget)
validate_response(response, wallet_3hf.create_budget.__name__)
check_virt_ops(wallet_3hf, response["block_num"], response["block_num"], {'create_budget'})
balance_after = wallet_3hf.get_account_scr_balance(budget["owner"])
assert balance_before == balance_after + budget_balance
update_budget_balance(wallet_3hf, budget)
assert budget_balance == Amount(budget['balance']) + Amount(budget['owner_pending_income']) + \
Amount(budget['budget_pending_outgo'])
per_block, _ = calc_per_block(get_per_blocks_count(start, deadline), budget_balance)
assert per_block == Amount(budget['per_block'])
budgets_summary = wallet_3hf.get_dynamic_global_properties()['advertising'][DGP_BUDGETS[budget['type']]]
assert all(budgets_summary[k] == budget[v] for k, v in DGP_PARAMS_MAP.items())
