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_cashout_scr_rewards(wallet_3hf: Wallet, budget, post):
balancer_delay = 7 # blocks to wait until SCR will be in each required pool
cfg = wallet_3hf.get_config()
# Advertising cashout_blocks count
adv_cash_blocks = int(cfg["SCORUM_ADVERTISING_CASHOUT_PERIOD_SEC"] / cfg["SCORUM_BLOCK_INTERVAL"])
# Post / comment cashout blocks count
# post_cash_blocks = int(cfg["SCORUM_CASHOUT_WINDOW_SECONDS"] / cfg["SCORUM_BLOCK_INTERVAL"])
# Active SP holders cashout blocks count
asph_cash_blocks = int(cfg["SCORUM_ACTIVE_SP_HOLDERS_REWARD_PERIOD"] / 1000000 / cfg["SCORUM_BLOCK_INTERVAL"]) - 1
update_budget_time(wallet_3hf, budget, deadline=300)
response = wallet_3hf.create_budget(**budget)
budget_cashout_block = response['block_num'] + adv_cash_blocks + balancer_delay
wallet_3hf.get_block(response['block_num'] + balancer_delay, wait_for_block=True)
wallet_3hf.post_comment(**post)
# post_cashout_block = response['block_num'] + post_cash_blocks
response = wallet_3hf.vote(DEFAULT_WITNESS, post['author'], post['permlink'])
active_sph_cashout_block = response['block_num'] + asph_cash_blocks
blocks_ops = [
(budget_cashout_block, 'producer_reward'),
(active_sph_cashout_block, 'active_sp_holders_reward'),
# (post_cashout_block, 'author_reward'),
# (post_cashout_block, 'curator_reward')
]
for cashout_block, op in blocks_ops:
wallet_3hf.get_block(cashout_block, wait_for_block=True)
ops = check_virt_ops(wallet_3hf, cashout_block, cashout_block, {op})
assert any(Amount(data['reward']) > 0 and 'SCR' in data['reward'] for name, data in ops if name == op)
def test_cashout_budgets_distribution(wallet_3hf: Wallet, budget, count, sync_start):
budgets, last_block = create_budgets(wallet_3hf, budget, count, sync_start)
owners = [b['owner'] for b in budgets]
cfg = wallet_3hf.get_config()
cashout_blocks_cnt = int(cfg["SCORUM_ADVERTISING_CASHOUT_PERIOD_SEC"] / cfg["SCORUM_BLOCK_INTERVAL"])
# collect data before cashout
capital_before, accounts_balances_before = get_affected_balances(wallet_3hf, owners)
[update_budget_balance(wallet_3hf, b) for b in budgets]
# wait until cashout
wallet_3hf.get_block(last_block + cashout_blocks_cnt, wait_for_block=True)
# collect data after cashout
capital_after, accounts_balances_after = get_affected_balances(wallet_3hf, owners)
[update_budget_balance(wallet_3hf, b) for b in budgets]
# calc delta between 'after', 'before' cashout states
capital_delta = get_capital_delta(capital_before, capital_after)
accounts_balances_delta = get_accounts_delta(accounts_balances_after, accounts_balances_before)
# calc total payments
total = get_total_sums(budgets, accounts_balances_delta, cashout_blocks_cnt)
# provide checks
assert capital_delta['dev_pool_scr_balance'] == total['to_dev_pool']
assert capital_delta['content_balancer_scr'] + \
capital_delta['content_reward_fund_scr_balance'] == total['to_activity_pool']
assert capital_delta['dev_pool_scr_balance'] + \
capital_delta['content_balancer_scr'] + \
capital_delta['content_reward_fund_scr_balance'] == total['spend']
def test_get_config(wallet: Wallet):
response = wallet.get_config()
validate_response(response, wallet.get_config.__name__, [
("SCORUM_HARDFORK_REQUIRED_WITNESSES", 17), ("SCORUM_MAX_VOTED_WITNESSES", 20),
("SCORUM_MAX_WITNESSES", 21), # ("SCORUM_ACTIVE_SP_HOLDERS_REWARD_PERIOD", int), due to BLOC-484
("SCORUM_ACTIVE_SP_HOLDERS_PER_BLOCK_REWARD_PERCENT", int),
("SCORUM_VESTING_WITHDRAW_INTERVALS", 52), ("SCORUM_VESTING_WITHDRAW_INTERVAL_SECONDS", int)
])
def test_validate_get_content(
wallet: Wallet, post_with_multilvl_comments, initdelegate_post, bob_comment_lv1, alice_comment_lv2
):
for post in post_with_multilvl_comments:
validate_response(wallet.post_comment(**post), wallet.post_comment.__name__)
time_config = wallet.get_config()
def validate_cashout_interval(comment: dict):
date_start = to_date(comment['created'])
date_finish = to_date(comment['cashout_time'])
delta = date_finish - date_start
cashout_window = int(time_config["SCORUM_CASHOUT_WINDOW_SECONDS"])
assert delta.total_seconds() == cashout_window
def validate_url(comment: dict):
if comment['parent_author']:
assert comment['url'] == '/{category}/@{root_author}/{root_permlink}#@{author}/{permlink}' \
.format(category=comment['category'],
root_author=post['author'],
root_permlink=post['permlink'],
author=comment['author'],
permlink=comment['permlink'])
else:
assert comment['url'] == '/{}/@{}/{}'.format(comment['category'], comment['author'], comment['permlink'])
def validate_content(comment, comment_kwargs, parent=None):
for key, value in comment_kwargs.items():
assert comment[key] == value, '{} value differs from expected'.format(key)
assert comment['category'] == initdelegate_post['parent_permlink']
expected_depth = parent['depth'] + 1 if parent else 0
assert comment['depth'] == expected_depth
assert comment['root_title'] == initdelegate_post['title']
assert comment['root_comment'] == post['id']
validate_cashout_interval(comment)
validate_url(comment)
post = wallet.get_content(initdelegate_post['author'], initdelegate_post['permlink'])
validate_content(post, initdelegate_post)
comment_level_1 = wallet.get_content(bob_comment_lv1['author'], bob_comment_lv1['permlink'])
validate_content(comment_level_1, bob_comment_lv1, post)
comment_level_2 = wallet.get_content(alice_comment_lv2['author'], alice_comment_lv2['permlink'])
validate_content(comment_level_2, alice_comment_lv2, comment_level_1)
def test_account_final_withdraw(wallet: Wallet, account, amount):
response = wallet.withdraw(account, amount)
validate_response(response, wallet.withdraw.__name__)
account_before = wallet.get_account(account)
constants = wallet.get_config()
intervals = constants["SCORUM_VESTING_WITHDRAW_INTERVALS"]
single_payment = amount / intervals
interval_sec = constants["SCORUM_VESTING_WITHDRAW_INTERVAL_SECONDS"]
for i in range(1, intervals + 1):
time.sleep(interval_sec + 1)
expected_withdraw = single_payment * i
transfers = wallet.get_account_transfers(account)
expect(len(transfers) == 1, "Was created more withdrawals then was expected.")
withdrawn = Amount(transfers[0][1]["withdrawn"])
expect(
withdrawn == expected_withdraw,
"step: %d, actual '%s', expected '%s'" % (i, withdrawn, expected_withdraw)
)
account_after = wallet.get_account(account)
sp_change = Amount(account_before["scorumpower"]) - Amount(account_after["scorumpower"])
expect(
sp_change == expected_withdraw,
"step: %d, actual '%s', expected '%s'" % (i, sp_change, expected_withdraw)
)
scr_change = Amount(account_after["balance"]) - Amount(account_before["balance"])
expect(
scr_change == expected_withdraw,
"step: %d, actual '%s', expected '%s'" % (i, scr_change, expected_withdraw)
)
assert_expectations()
if i == intervals:
assert transfers[0][1]["status"] == "finished"
def test_get_config(wallet: Wallet):
response = wallet.get_config()
validate_response(
response,
wallet.get_config.__name__,
[
("SCORUM_HARDFORK_REQUIRED_WITNESSES", 17),
("SCORUM_MAX_VOTED_WITNESSES", 20),
(
"SCORUM_MAX_WITNESSES", 21
), # ("SCORUM_ACTIVE_SP_HOLDERS_REWARD_PERIOD", int), due to BLOC-484
("SCORUM_ACTIVE_SP_HOLDERS_PER_BLOCK_REWARD_PERCENT", int),
("SCORUM_VESTING_WITHDRAW_INTERVALS", 52),
("SCORUM_VESTING_WITHDRAW_INTERVAL_SECONDS", int),
("SCORUM_LOW_MEMORY_NODE", bool),
("SCORUM_CLEAR_VOTES", bool),
("SCORUM_SKIP_BY_TX_ID", bool),
("SCORUM_LIVE_TESTNET", bool),
("SCORUM_ADVERTISING_CASHOUT_PERIOD_SEC", int),
("SCORUM_BUDGETS_LIMIT_PER_OWNER", 100)
])
def test_get_discussions_by_author_order(wallet: Wallet, initdelegate_post):
permlinks = ["initdelegate-post-%d" % i for i in range(1, 5)]
post_creation_interval = int(
int(wallet.get_config()["SCORUM_MIN_ROOT_COMMENT_INTERVAL"]) / 1000000)
for permlink in permlinks:
initdelegate_post["permlink"] = permlink
res = wallet.post_comment(**initdelegate_post)
validate_response(res, wallet.post_comment.__name__)
if permlink != permlinks[-1]:
time.sleep(post_creation_interval) # 5 min for each post on prod
discussions = wallet.get_discussions_by(
"author", **{
"start_author": DEFAULT_WITNESS,
"limit": len(permlinks)
})
validate_response(discussions, "get_discussions_by_author")
total_posts = len(permlinks)
for current in range(0, total_posts):
opposite = total_posts - current - 1
assert permlinks[current] == discussions[opposite]["permlink"], \
"Broken posts order, Post %d should be on %d position." % (current, opposite)
def test_get_paid_posts_comments_by_author(wallet: Wallet, initdelegate_post):
# REQUIREMENTS: return an array of posts and comments belonging to the given author that have reached cashout time.
# This method should allow for pagination. The query should include field that will filter posts/comments that
# have 0 SP rewards. The posts/comments should be sorted by last_payout field in the descending order.
permlinks = ["initdelegate-post-%d" % i for i in range(1, 2)]
post_creation_interval = int(
int(wallet.get_config()["SCORUM_MIN_ROOT_COMMENT_INTERVAL"]) / 1000000)
for permlink in permlinks:
initdelegate_post["permlink"] = permlink
res = wallet.post_comment(**initdelegate_post)
validate_response(res, wallet.post_comment.__name__)
# print(wallet.get_content(DEFAULT_WITNESS, permlink))
if permlink != permlinks[-1]:
time.sleep(post_creation_interval) # 5 min for each post on prod
posts = wallet.get_paid_posts_comments_by_author(**{
"start_author": DEFAULT_WITNESS,
"limit": len(permlinks)
})
assert len(posts) == len(permlinks)
def test_create_max_budgets(wallet_3hf: Wallet, budget):
re_budgets_limit = r"Can't create more then .* budgets per owner."
limit = wallet_3hf.get_config()["SCORUM_BUDGETS_LIMIT_PER_OWNER"]
balance = "0.000000001 SCR"
update_budget_time(wallet_3hf, budget, start=5, deadline=300)
budgets = []
for i in range(1, limit + 1):
budget_cp = copy(budget)
budget_cp.update({'uuid': gen_uid(), 'balance': balance})
budgets.append(budget_cp)
validate_response(
wallet_3hf.broadcast_multiple_ops('create_budget_operation', budgets, {budget['owner']}),
'create_budget_operation'
)
update_budget_time(wallet_3hf, budget, start=5, deadline=300)
validate_error_response(
wallet_3hf.create_budget(**budget),
wallet_3hf.create_budget.__name__,
re_budgets_limit
)
wallet_3hf.close_budget(str(budgets[0]['uuid']), budget['owner'], budget['type'])
update_budget_time(wallet_3hf, budget, start=5, deadline=300)
validate_response(wallet_3hf.create_budget(**budget), wallet_3hf.create_budget.__name__)
