def write_posts_stats(posts, fifa_pool):
with open("fifa_posts_result.csv", "w") as csvfile:
authors_payouts = defaultdict(Amount)
writer = csv.writer(csvfile, delimiter=";")
writer.writerow([
"author", "actual_reward_by_net_rshares_distribution",
"fifa_percent", "post_author_payout", "payout_percent",
"net_rshares", "permlink"
])
for addr, post in posts.items():
reward = post["expected_reward"]
if reward > Amount("0 SP"):
fifa_percent = percentage(reward.amount, fifa_pool.amount)
author, permlink = addr.split(":")
author_payout = Amount(post["author_payout_sp_value"])
payout_percent = percentage(reward.amount,
author_payout.amount)
writer.writerow([
author,
str(reward), fifa_percent,
str(author_payout), payout_percent,
int(post["net_rshares"]), permlink
])
authors_payouts[author] += author_payout
return authors_payouts
def test_close_after_starttime(wallet_3hf: Wallet, budget, moderator):
update_budget_time(wallet_3hf, budget)
budget_balance = Amount(budget["balance"])
balance_before = wallet_3hf.get_account_scr_balance(budget["owner"])
response = wallet_3hf.create_budget(**budget)
create_block = response["block_num"]
update_budget_balance(wallet_3hf,
budget) # update budget params / set budget id
per_block = Amount(budget["per_block"])
balance_after_create = wallet_3hf.get_account_scr_balance(budget["owner"])
assert balance_before - balance_after_create == budget_balance
empower_advertising_moderator(wallet_3hf, moderator)
response = wallet_3hf.close_budget_by_advertising_moderator(
budget["uuid"], moderator, budget["type"])
validate_response(
response, wallet_3hf.close_budget_by_advertising_moderator.__name__)
close_block = response["block_num"]
balance_after_close = wallet_3hf.get_account_scr_balance(budget["owner"])
assert balance_after_close == balance_after_create + budget_balance - per_block * (
close_block - create_block)
check_virt_ops(
wallet_3hf, close_block, close_block, {
'close_budget_by_advertising_moderator', 'budget_closing',
'budget_owner_income', 'budget_outgo'
})
assert len(wallet_3hf.get_budgets([budget['owner']], budget['type'])) == 0
assert len(wallet_3hf.list_buddget_owners(budget_type=budget['type'])) == 0
def write_accounts_stats(accounts, authors_payouts, fifa_pool):
with open("fifa_accounts_result.csv", "w") as csvfile:
writer = csv.writer(csvfile, delimiter=";")
writer.writerow([
"name", "actual_reward_by_net_rshares_distribution",
"fifa_percent", "author_posts_payouts", "payout_percent",
"balance_before_fifa", "gain_percent",
"potential_reward_by_sp_distribution", "exp_posting_percent"
])
for name, acc in accounts.items():
reward = acc["expected_reward"]
if reward > Amount("0 SP"):
fifa_percent = percentage(reward.amount, fifa_pool.amount)
author_payout = authors_payouts[name]
payout_percent = percentage(reward.amount,
author_payout.amount)
balance = Amount(acc["scorumpower"])
gain_percent = percentage(reward.amount, balance.amount)
exp_posting_reward = acc["expected_posting_reward"]
exp_posting_percent = percentage(exp_posting_reward.amount,
fifa_pool.amount)
writer.writerow([
name,
str(reward), fifa_percent,
str(author_payout), payout_percent,
str(balance), gain_percent, exp_posting_reward,
exp_posting_percent
])
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_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_devcommittee_active_withdraw(wallet: Wallet):
amount = Amount("10.000000000 SP")
validate_response(
wallet.devcommittee_withdraw_vesting(DEFAULT_WITNESS, amount),
wallet.devcommittee_withdraw_vesting.__name__
)
proposals = wallet.list_proposals()
validate_response(proposals, wallet.list_proposals.__name__)
assert len(proposals) == 1, "Was created %d proposals, expected only one: %s" % (len(proposals), proposals)
validate_response(wallet.proposal_vote(DEFAULT_WITNESS, proposals[0]["id"]), wallet.proposal_vote.__name__)
transfers = wallet.get_devcommittee_transfers()
validate_response(transfers, wallet.get_devcommittee_transfers.__name__)
assert len(transfers) == 1, "Was created more transfers then was expected."
withdraw = transfers[0]
expect(withdraw["status"] == "active")
expect(Amount(withdraw["withdrawn"]) == Amount("0 SP")) # e.g. any payment was not provided yet
expect(withdraw["op"][0] == "proposal_virtual")
expect(withdraw["op"][1]["proposal_op"][0] == "development_committee_withdraw_vesting")
expect(Amount(withdraw["op"][1]["proposal_op"][1]["vesting_shares"]) == amount)
assert_expectations()
def test_devcommittee_zero_withdraw_2hf(wallet: Wallet):
# on prev HF zero-withdraw was not allowed for devcommittee
apply_hardfork(wallet, 2)
amount = Amount("99.000000000 SP")
validate_response(
wallet.devcommittee_withdraw_vesting(DEFAULT_WITNESS, amount),
wallet.devcommittee_withdraw_vesting.__name__
)
proposals = wallet.list_proposals()
validate_response(proposals, wallet.list_proposals.__name__)
expect(len(proposals) == 1, "Was created %d proposals, expected only one: %s" % (len(proposals), proposals))
validate_response(wallet.proposal_vote(DEFAULT_WITNESS, proposals[0]["id"]), wallet.proposal_vote.__name__)
validate_response(
wallet.devcommittee_withdraw_vesting(DEFAULT_WITNESS, Amount("0 SP")),
wallet.devcommittee_withdraw_vesting.__name__
)
proposals = wallet.list_proposals()
validate_response(proposals, wallet.list_proposals.__name__)
expect(len(proposals) == 1, "Was created %d proposals, expected one: %s" % (len(proposals), proposals))
validate_response(wallet.proposal_vote(DEFAULT_WITNESS, proposals[0]["id"]), wallet.proposal_vote.__name__)
transfers = wallet.get_devcommittee_transfers()
validate_response(transfers, wallet.get_devcommittee_transfers.__name__)
expect(len(transfers) == 2, "Was created unexpected amount of transfers.")
expect(transfers[0]["status"] == "empty")
expect(transfers[1]["status"] == "interrupted")
assert_expectations()
def get_fifa_operations(operations, cashout_posts):
fifa_ops = []
additional_ops = []
for num, data in operations:
op = data["op"][0]
if op != "comment_reward":
continue
addr = "%s:%s" % (data["op"][1]["author"], data["op"][1]["permlink"])
if addr in cashout_posts:
cashout_posts.remove(addr)
additional_ops.append([num, data])
else:
fifa_ops.append([num, data])
save_to_file("fifa_operations.json", fifa_ops)
if cashout_posts:
logging.critical(cashout_posts)
if additional_ops:
save_to_file("additional_operations.json", additional_ops)
fund_sum = Amount("0 SP")
author_sum = Amount("0 SP")
for num, data in additional_ops:
fund_sum += Amount(data["op"][1]["fund_reward"])
author_sum += Amount(data["op"][1]["author_reward"])
logging.info("Additional rewards: fund '%s', author '%s' ",
str(fund_sum), str(author_sum))
return fifa_ops, additional_ops
def get_total_sums(budgets, accs_delta, blocks_cnt):
total = {'to_dev_pool': Amount(), 'to_activity_pool': Amount(), 'spend': Amount()}
for b in budgets:
spend = Amount(b['per_block']) * blocks_cnt - accs_delta[b['owner']]
dev_pool = spend // 2
activity_pool = spend - dev_pool
total['spend'] += spend
total['to_dev_pool'] += dev_pool
total['to_activity_pool'] += activity_pool
return total
def check_comments_actual_reward_sum_equal_to_fifa_pull_size(posts, fifa_pool):
fund_sum = Amount("0 SP")
for post in posts.values():
fund_sum += post["actual_reward"]
msg = "Sum of actual fund rewards is not equal to fifa pool: %s" % \
comparison_str(fifa_pool, fund_sum)
# assert Amount("-0.005 SP") <= fund_sum - fifa_pool <= Amount("0.005 SP"), msg
if Amount("-0.000005 SP") <= fund_sum - fifa_pool <= Amount("0.000005 SP"):
return
logging.error(msg)
def check_accounts_scr_balance_has_not_changed(accounts_before,
accounts_after):
errors = 0
for name in accounts_before.keys():
scr_before = Amount(accounts_before[name]["balance"])
scr_after = Amount(accounts_after[name]["balance"])
msg = "Amount of SCR balance has changed for '%s'" % name
# assert scr_after - scr_before == Amount("0 SCR"), msg
if scr_after - scr_before == Amount("0 SCR"):
continue
logging.error(msg)
errors += 1
if not errors:
logging.info("check_accounts_scr_balance_has_not_changed - OK")
def calc_posts_actual_rewards(posts, operations):
for _, post in posts.items():
post.update({
"actual_reward": Amount("0 SP"),
"commenting_reward": Amount("0 SP")
})
op_num = 0
fund_sum = Amount("0 SP")
commenting_sum = Amount("0 SP")
missed_posts = set()
for num, data in operations:
author = data["op"][1]["author"]
permlink = data["op"][1]["permlink"]
address = "%s:%s" % (author, permlink)
if address not in posts:
missed_posts.add(address)
continue
posts[address]["actual_reward"] += Amount(data["op"][1]["fund_reward"])
fund_sum += Amount(data["op"][1]["fund_reward"])
posts[address]["commenting_reward"] += Amount(
data["op"][1]["commenting_reward"])
commenting_sum += Amount(data["op"][1]["commenting_reward"])
op_num += 1
if missed_posts:
logging.error("Unexpected '%d' comment_reward operation for posts: %s",
len(missed_posts), missed_posts)
logging.info(
"Total number of comment_reward operations: %d, fund_reward sum: '%s', commenting_reward sum: '%s'",
op_num, str(fund_sum), str(commenting_sum))
def check_posts_fund_reward_distribution(posts_before, posts_after):
errors = 0
for address in posts_before.keys():
expected = posts_before[address]["expected_reward"]
actual = posts_after[address]["actual_reward"]
msg = "Post actual and expected rewards are not equal: %s, author_permlink '%s'" % \
(comparison_str(expected, actual), address)
if Amount("-0.000005 SP") <= actual - expected <= Amount(
"0.000005 SP"):
continue
logging.error(msg)
errors += 1
if not errors:
logging.info("check_posts_fund_reward_distribution - OK")
def get_pending_delta(before, after):
before_map = {b['uuid']: b for b in before}
after_map = {a['uuid']: a for a in after}
delta = dict()
for k, v in after_map.items():
if k not in before_map:
delta[k] = {INCOME: v[INCOME], OUTGO: v[OUTGO], 'per_block': v['per_block']}
else:
delta[k] = {
INCOME: str(Amount(v[INCOME]) - Amount(before_map[k][INCOME])),
OUTGO: str(Amount(v[OUTGO]) - Amount(before_map[k][OUTGO])),
'per_block': v['per_block']
}
return sorted(delta.values(), key=lambda x: x['per_block'], reverse=True)
def calculate_supplies(self):
# calculate accounts supply
for ga in self.genesis_accounts:
self.accounts_supply += ga.amount
account = {
'name': ga.account.name,
'scr_amount': str(ga.amount),
'public_key': ga.account.get_owner_public()
}
self['accounts'].append(account)
self['accounts_supply'] = str(self.accounts_supply)
# collect witnesses
self['witness_candidates'] = [{
'name':
acc.name,
'block_signing_key':
acc.get_signing_public()
} for acc in self.witness_candidates]
# collect founders
self['founders'] = [{
'name': name,
'sp_percent': percent
} for name, percent in self.founders]
# collect dev_committee
self['development_committee'] = list(self.dev_committee)
# collect reg_committee
self['registration_committee'] = list(self.reg_committee)
# calculate steemit_bounty supply
bounty_per_acc = Amount(self['steemit_bounty_accounts_supply']) / len(
self.steemit_bounty_accounts)
self['steemit_bounty_accounts'] = [{
'name': acc,
'sp_amount': str(bounty_per_acc)
} for acc in self.steemit_bounty_accounts]
self.steemit_bounty_supply = bounty_per_acc * len(
self.steemit_bounty_accounts)
self['steemit_bounty_accounts_supply'] = str(
self.steemit_bounty_supply)
# calculate total supply
supplies = [
'accounts_supply', 'rewards_supply', 'registration_supply',
'founders_supply', 'steemit_bounty_accounts_supply',
'development_sp_supply', 'development_scr_supply'
]
total = Amount()
for supply in supplies:
total += Amount(self[supply])
self['total_supply'] = str(total)
def test_devcommittee_withdraw_gt_pool(wallet: Wallet):
devcommittee = wallet.get_development_committee()
validate_response(devcommittee, wallet.get_development_committee.__name__)
amount = Amount(devcommittee["sp_balance"]) + Amount("100.000000000 SP")
validate_response(
wallet.devcommittee_withdraw_vesting(DEFAULT_WITNESS, amount),
wallet.devcommittee_withdraw_vesting.__name__
)
proposals = wallet.list_proposals()
validate_response(proposals, wallet.list_proposals.__name__)
expect(len(proposals) == 1, "Was created %d proposals, expected only one: %s" % (len(proposals), proposals))
validate_error_response(wallet.proposal_vote(DEFAULT_WITNESS, proposals[0]["id"]), wallet.proposal_vote.__name__)
def check_accounts_fund_reward_distribution(accounts_before, accounts_after):
errors = 0
for name in accounts_before.keys():
expected = accounts_before[name]["expected_reward"]
actual = accounts_after[name]["actual_reward"]
msg = "Account actual and expected rewards are not equal: %s, name '%s'" % \
(comparison_str(expected, actual), name)
# assert Amount("-0.000005 SP") <= actual - expected <= Amount("0.000005 SP"), msg
if Amount("-0.000005 SP") <= actual - expected <= Amount(
"0.000005 SP"):
continue
logging.error(msg)
errors += 1
if not errors:
logging.info("check_accounts_fund_reward_distribution - OK")
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_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_close_before_starttime(wallet_3hf: Wallet, budget, moderator):
update_budget_time(wallet_3hf, budget, start=30,
deadline=60) # to delay opening time for budget
budget_balance = Amount(budget["balance"])
balance_before = wallet_3hf.get_account_scr_balance(budget["owner"])
wallet_3hf.create_budget(**budget)
update_budget_balance(wallet_3hf,
budget) # update budget params / set budget id
balance_after_create = wallet_3hf.get_account_scr_balance(budget["owner"])
assert balance_before - balance_after_create == budget_balance
empower_advertising_moderator(wallet_3hf, moderator)
response = wallet_3hf.close_budget_by_advertising_moderator(
budget["uuid"], moderator, budget["type"])
validate_response(
response, wallet_3hf.close_budget_by_advertising_moderator.__name__)
balance_after_close = wallet_3hf.get_account_scr_balance(budget["owner"])
assert balance_after_close == balance_after_create + budget_balance
check_virt_ops(
wallet_3hf, response['block_num'], response['block_num'], {
'close_budget_by_advertising_moderator', 'budget_closing',
'budget_owner_income'
})
assert len(wallet_3hf.get_budgets([budget['owner']], budget['type'])) == 0
assert len(wallet_3hf.list_buddget_owners(budget_type=budget['type'])) == 0
def create_account(self,
creator: str,
newname: str,
owner: str,
active: str = None,
posting: str = None,
fee: Amount = None,
memo=None,
json_meta={},
additional_owner_keys=[],
additional_active_keys=[],
additional_posting_keys=[],
additional_owner_accounts=[],
additional_active_accounts=[],
additional_posting_accounts=[]):
op = operations.account_create_operation(
creator, fee if fee else Amount('0.000000750 SCR'), newname, owner,
active if active else owner, posting if posting else owner,
memo if memo else owner, json_meta, additional_owner_accounts,
additional_active_accounts, additional_posting_accounts,
additional_owner_keys, additional_active_keys,
additional_posting_keys)
signing_key = self.account(creator).get_active_private()
return self.broadcast_transaction_synchronous([op], [signing_key])
def calculate_rewards_from_genesis():
blocks_per_month = 864000
days_in_month = 30
days_in_2_years = 730
rewards_supply = Amount(genesis['rewards_supply'])
rewards_per_block = rewards_supply * days_in_month / days_in_2_years / blocks_per_month
return rewards_per_block
def test_serialize_devpool_withdraw_vesting_proposal_create_to_byte():
op = devpool_withdraw_vesting("initdelegate", Amount("10.000000000 SP"),
86400)
signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
result_bin = b'1d0c696e697464656c6567617465805101000600e40b54020000000953500000000000'
assert hexlify(bytes(signed_ops.data[0])) == result_bin
def check_accounts_sp_gain_equal_to_fifa_pool_size(accounts_before,
accounts_after, fifa_pool):
total_gain = Amount("0 SP")
for name in accounts_before.keys():
sp_before = Amount(accounts_before[name]["scorumpower"])
sp_after = Amount(accounts_after[name]["scorumpower"])
total_gain += sp_after - sp_before
msg = "Amount of sp balance gain is not equal to fifa pool: %s" % \
comparison_str(fifa_pool, total_gain)
# assert total_gain == fifa_pool, msg
if total_gain == fifa_pool:
logging.info(
"check_sum_of_authors_sp_balance_gain_equal_to_fifa_pool_size - OK"
)
return
logging.error(msg)
def check_fifa_pool_after_distribution_equal_zero(fifa_pool):
msg = "Fifa pool after payment is not equal to zero: %s" % str(fifa_pool)
# assert fifa_pool == Amount("0 SP"), msg
if fifa_pool == Amount("0 SP"):
logging.info("check_fifa_pool_after_distribution_equal_zero - OK")
return
logging.error(msg)
def check_balances_of_expected_accounts_increased(accounts_before,
accounts_after):
errors = 0
for name in accounts_before.keys():
gain = Amount(accounts_after[name]["scorumpower"]) - Amount(
accounts_before[name]["scorumpower"])
is_reward_expected = accounts_before[name]["is_reward_expected"]
if is_reward_expected:
msg = "Balance of '%s' account has not changed (gain expected)." % name
# assert gain > Amount("0 SP"), msg
if gain > Amount("0 SP"):
continue
logging.error(msg)
errors += 1
if not errors:
logging.info("check_balances_of_expected_accounts_increased - OK")
def test_create_budget(wallet: Wallet):
owner = DEFAULT_WITNESS
response = wallet.create_budget(owner, Amount("10.000000000 SCR"),
fmt_time_from_now(10),
fmt_time_from_now(40))
validate_response(response, wallet.create_budget.__name__)
budget = wallet.get_budgets(owner)[0]
print(budget)
per_block_for_10_blocks_budget = Amount('1.000000000 SCR')
per_block_for_9_blocks_budget = Amount('1.034482758 SCR')
assert owner in wallet.list_buddget_owners()
assert Amount(budget['per_block']) in (per_block_for_10_blocks_budget,
per_block_for_9_blocks_budget)
assert budget['owner'] == owner
def test_serialize_create_budget_to_byte():
op = create_budget_operation("initdelegate", "{}",
Amount("10.000000000 SCR"),
"2018-08-03T10:12:43", "2018-08-03T10:13:13",
"post")
signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
result_bin = b'1a00000000000000000c696e697464656c6567617465027b7d00e40b540200000009534352000000009b2a645bb92a645b'
assert hexlify(bytes(signed_ops.data[0])) == result_bin
def test_account_active_withdraw(wallet: Wallet, account, amount):
response = wallet.withdraw(account, amount)
validate_response(response, wallet.withdraw.__name__)
transfers = wallet.get_account_transfers(account)
expect(len(transfers) == 1, "Was created more withdrawals then was expected.")
withdraw = transfers[0][1]
expect(withdraw["status"] == "active")
expect(Amount(withdraw["withdrawn"]) == Amount("0 SP")) # e.g. any payment was not provided yet
expect(withdraw["op"][0] == "withdraw_scorumpower")
expect(Amount(withdraw["op"][1]["scorumpower"]) == amount)
expect(withdraw["op"][1]["account"] == account)
assert_expectations()
def check_expected_posts_received_reward(posts_before, posts_after):
posts_to_reward = set(address for address in posts_before
if posts_before[address]["is_reward_expected"])
rewarded_posts = set(
address for address in posts_after
if posts_after[address]["actual_reward"] > Amount("0 SP")
or posts_after[address]["commenting_reward"] > Amount("0 SP"))
missing = posts_to_reward.difference(rewarded_posts)
if missing:
logging.error("Missing comment_reward_operations for %d posts: %s",
len(missing), missing)
unexpected = rewarded_posts.difference(posts_to_reward)
if unexpected:
logging.error("Unexpected comment_reward_operations for %d posts: %s",
len(unexpected), unexpected)
if not missing and not unexpected:
logging.info("check_expected_posts_received_reward - OK")