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")