def curation_stats(self): trailing_24hr_t = time.time() - datetime.timedelta( hours=24).total_seconds() trailing_7d_t = time.time() - datetime.timedelta( days=7).total_seconds() reward_24h = 0.0 reward_7d = 0.0 for reward in self.history2(filter_by="curation_reward", take=10000): timestamp = parse_time(reward['timestamp']).timestamp() if timestamp > trailing_7d_t: reward_7d += Amount(reward['reward']).amount if timestamp > trailing_24hr_t: reward_24h += Amount(reward['reward']).amount reward_7d = self.converter.vests_to_sp(reward_7d) reward_24h = self.converter.vests_to_sp(reward_24h) return { "24hr": reward_24h, "7d": reward_7d, "avg": reward_7d / 7, }
def have_bandwidth(steem, account): ''' Determine if the given account has enough bandwidth to do stuff. Note that this is just an estimate to return approximately >20% bandwidth remaining. ''' # FIXME: rewrite this once we get a better calculation for determining available bandwidth props = steem.get_dynamic_global_properties() log.debug("got global properties", props=props) total_vests = Amount(props['total_vesting_shares']).amount max_bandwidth = int(props['max_virtual_bandwidth']) vests = Amount(account['vesting_shares']).amount bw_post = steem.get_account_bandwidth(account.name, "post") bw_forum = steem.get_account_bandwidth(account.name, "forum") bw_market = steem.get_account_bandwidth(account.name, "market") log.debug("account bandwidth information", vests=vests, post=bw_post, forum=bw_forum, market=bw_market) bw_allocated = vests / total_vests bw_used = (int(bw_market['average_bandwidth']) + int(bw_forum['average_bandwidth'])) / max_bandwidth ratio = bw_used / bw_allocated log.debug("bandwidth calculation", allocated=bw_allocated, used=bw_used, ratio=ratio) return ratio < 9
def check_balances(self, account=None): if account is None: account = self.mainaccount try: self.votepower except: pass else: if account == self.checkedaccount: return [ self.sbdbal, self.steembal, self.steempower, self.votepower, self.lastvotetime ] self.checkedaccount = account try: acct = self.steem_instance().get_account(account) except Exception as e: self.msg.error_message(e) return False else: c = Converter() self.sbdbal = Amount(acct['sbd_balance']).amount or 0 self.steembal = Amount(acct['balance']).amount or 0 self.votepower = acct['voting_power'] self.lastvotetime = acct['last_vote_time'] vs = Amount(acct['vesting_shares']).amount dvests = Amount(acct['delegated_vesting_shares']).amount rvests = Amount(acct['received_vesting_shares']).amount vests = (float(vs) - float(dvests)) + float(rvests) self.steempower = c.vests_to_sp(vests) or 0 time.sleep(5) return [ self.sbdbal, self.steembal, self.steempower, self.votepower, self.lastvotetime ]
def check_balances(self, account=None): ''' Fetches an account balance and makes necessary conversions ''' a = self.account(account) if a is not False and a is not None: self.sbdbal = Amount(a['sbd_balance']).amount self.steembal = Amount(a['balance']).amount self.votepower = a['voting_power'] self.lastvotetime = a['last_vote_time'] vs = Amount(a['vesting_shares']).amount dvests = Amount(a['delegated_vesting_shares']).amount rvests = Amount(a['received_vesting_shares']).amount vests = (float(vs) - float(dvests)) + float(rvests) try: self.global_props() self.steempower_delegated = self.util.vests_to_sp(dvests) self.steempower_raw = self.util.vests_to_sp(vs) self.steempower = self.util.vests_to_sp(vests) except Exception as e: self.msg.error_message(e) self.e = e else: return [self.sbdbal, self.steembal, self.steempower, self.votepower, self.lastvotetime] return False
def vests_to_sp(vests, info): steem_per_mvests = ( Amount(info["total_vesting_fund_steem"]).amount / (Amount(info["total_vesting_shares"]).amount / 1e6) ) return vests / 1e6 * steem_per_mvests
def action(self): return "%s claimed rewards: %s sbd, %s steem, %.2f vests." % ( self.actor, Amount(self.raw_data["reward_sbd"]), Amount(self.raw_data["reward_steem"]), Amount(self.raw_data["reward_vests"]) )
def action(self): return '%s got %s for <a href="%s">%s</a>. ' \ '<br>%s sbd, %s steem, %.2f vests.' % \ (self.actor, self.exact_action, self.link, self.raw_data["permlink"], Amount(self.raw_data["sbd_payout"]).amount, Amount(self.raw_data["steem_payout"]).amount, Amount(self.raw_data["vesting_payout"]).amount)
def convert_rshares(self, rshares): reward_fund = self.steem.get_reward_fund() reward_balance, recent_claims = (reward_fund["reward_balance"], reward_fund["recent_claims"]) base_price = self.steem.get_current_median_history_price()["base"] fund_per_share = Amount(reward_balance).amount / float(recent_claims) payout = float(rshares) * fund_per_share * Amount(base_price).amount return payout
def balances(self): steem_balance = "%.3f" % Amount(self.account_data['balance']).amount sbd_balance = "%.3f" % Amount(self.account_data['sbd_balance']).amount vests = "%.3f" % Amount(self.account_data['vesting_shares']).amount return { 'STEEM': steem_balance, 'SBD': sbd_balance, 'VESTS': vests, }
def getvotevalue(SP, VotingPower, VotingWeight): POWER = SP / (float(Amount(steem.steemd.get_dynamic_global_properties()['total_vesting_fund_steem']).amount) \ / float(steem.steemd.get_dynamic_global_properties()['total_vesting_shares'].rstrip(' VESTS'))) VOTING = ((100 * VotingPower * (100 * VotingWeight) / 10000) + 49) / 50 REW = float(Amount(steem.steemd.get_reward_fund()['reward_balance']).amount) \ / float(steem.steemd.get_reward_fund()['recent_claims']) PRICE = float(Amount(steem.steemd.get_current_median_history_price()['base']).amount) \ / float(Amount(steem.steemd.get_current_median_history_price()['quote']).amount) VoteValue = (POWER * VOTING * 100) * REW * PRICE return VoteValue
def getvoteweight(SP, VoteValue, VotingPower): POWER = SP / (float(Amount(steem.steemd.get_dynamic_global_properties()['total_vesting_fund_steem']).amount) \ / float(steem.steemd.get_dynamic_global_properties()['total_vesting_shares'].rstrip(' VESTS'))) REW = float(Amount(steem.steemd.get_reward_fund()['reward_balance']).amount) \ / float(steem.steemd.get_reward_fund()['recent_claims']) PRICE = float(Amount(steem.steemd.get_current_median_history_price()['base']).amount) \ / float(Amount(steem.steemd.get_current_median_history_price()['quote']).amount) VOTING = VoteValue / (POWER * 100 * REW * PRICE) VotingWeight = ((VOTING * 50 - 49) * 10000) / (100 * 100 * VotingPower) return VotingWeight
def reward_pool_balances(self): try: self.reward_balance except: reward_fund = self.steem_instance().get_reward_fund() self.reward_balance = Amount(reward_fund["reward_balance"]).amount self.recent_claims = float(reward_fund["recent_claims"]) self.base = Amount( self.steem_instance().get_current_median_history_price() ["base"]).amount return [self.reward_balance, self.recent_claims, self.base]
def pending_payout(username): context = {} for post in steem.get_blog(username, 500, 500): post = Post(post["comment"]) if post.is_main_post() and post["author"] == username: if "1970-01-01 00:00:00" == str(post["last_payout"]): payout = Amount(post["pending_payout_value"]).amount if payout == 0: payout = (Amount(post["total_payout_value"]).amount + Amount(post["curator_payout_value"]).amount) context[post.title] = payout * 0.56 * 0.5 return context
def calculate_voteworth(self): # To calculate the vote worth reward_fund = s.get_reward_fund() sbd_median_price = s.get_current_median_history_price() vests = Amount(self.data['vesting_shares']) + Amount( self.data['received_vesting_shares']) - Amount( self.data['delegated_vesting_shares']) vestingShares = int(vests * 1e6) rshares = 0.02 * vestingShares estimated_upvote = rshares / float( reward_fund['recent_claims']) * Amount( reward_fund['reward_balance']).amount * Amount( sbd_median_price['base']).amount estimated_upvote = estimated_upvote * ( float(self.data['voting_power']) / 10000) return ('$' + str(round(estimated_upvote, 2)))
def x_get_steemit_balances(mode): results = steemax.axdb.x_fetch_reward_fund(mode) if steemax.axdb.x_check_reward_fund_renewal(results[3]): # Get and the current Steemit reward fund steem-python object used to retreive the following values reward_fund = s.get_reward_fund() # The current Steemit reward balance (reward pool) reward_balance = Amount(reward_fund["reward_balance"]).amount # The recent claims made on the reward balance (upvotes for the day subtracting from the reward pool) recent_claims = float(reward_fund["recent_claims"]) # The price of Steem in USD base = Amount(s.get_current_median_history_price()["base"]).amount # Save to database steemax.axdb.x_save_reward_fund(reward_balance, recent_claims, base, mode) # Print to screen if mode == "verbose": print("\n------------------------------------------------") print(" Reward balance: " + str(reward_balance)) print(" Recent claims: " + str(recent_claims)) print(" Steem = $" + str(base)) print("------------------------------------------------\n") return [reward_balance, recent_claims, base] else: if mode == "verbose": print("\n------------------------------------------------") print(" Reward balance: " + str(results[0])) print(" Recent claims: " + str(results[1])) print(" Steem = $" + str(results[0])) print("------------------------------------------------\n") return [results[0], results[1], results[2]]
def rewards(USERNAME): print() print(WHITEONBLUE + " " + USERNAME.upper() + " ACCOUNT " + GREENONBLACK) print() acc = steem.get_account(USERNAME) account = Account(USERNAME) reward_SBD = acc["reward_sbd_balance"] reward_SP = acc["reward_vesting_steem"] print("\n\nYour current rewards: {} and {} POWER".format( reward_SBD, reward_SP)) allSP = float(acc.get('vesting_shares').rstrip(' VESTS')) delSP = float(acc.get('delegated_vesting_shares').rstrip(' VESTS')) recSP = float(acc.get('received_vesting_shares').rstrip(' VESTS')) activeSP = account.converter.vests_to_sp(allSP - delSP + recSP) print("\n\nSTEEM POWER\t{:0.6f}".format(activeSP)) sbd_balance = Amount(acc["sbd_balance"]).amount lowest_ask = float(steem.get_ticker()["lowest_ask"]) print("\n\nSBD BALANCE\t{:0.6f}".format(sbd_balance)) print("\n\nSTEEMSBD:\t{:0.6f}".format(lowest_ask, )) sbdbase = float( Amount(steem.steemd.get_feed_history()['current_median_history'] ['base']).amount) print("\n\nMARKET:") print("\nSTEEMUSD:\t{}".format(locale.currency(get_steem_price()))) print("\nSBDUSD:\t{}".format(locale.currency(get_sbd_price()))) print("\n\nINTERNAL:") print("\n\nSTEEMUSD:\t{}".format(locale.currency(sbdbase))) sbdusd = sbdbase / lowest_ask print("\n\nSBDUSD:\t{}".format(locale.currency(sbdusd))) print("\n\nSBD USD BALANCE\t\t{}".format( locale.currency(sbd_balance * sbdusd))) print("\n\nSP USD BALANCE\t\t{}".format(locale.currency(activeSP * sbdbase))) print("\n\n{}TOTAL BALANCE\t\t{}{}\n\n\n".format( GREENONGREY, locale.currency((activeSP * sbdbase) + (sbd_balance * sbdusd)), GREENONBLACK))
def claim_all_reward_balance(steem, account): """Helper funtion to claim rewards because of bug in Steem""" acc = Account(account, steem) reward_steem = acc['reward_steem_balance'] reward_sbd = acc['reward_sbd_balance'] reward_vests = acc['reward_vesting_balance'] logger.info('Claiming {}, {}, and {} for {}'.format(reward_sbd, reward_vests, reward_steem, account)) op = operations.ClaimRewardBalance(account=account, reward_steem=reward_steem, reward_sbd=reward_sbd, reward_vests=reward_vests) can_claim = any(Amount(x).amount > 0 for x in (reward_sbd, reward_vests, reward_steem)) if can_claim: try: return error_retry(steem.commit.finalizeOp)(op, account, "posting") except Exception: logger.exception('Could not claim rewards {}. ' 'Reconnecting...'.format((reward_sbd, reward_vests, reward_steem))) steem.reconnect() else: logger.info('Nothing to claim!')
def getrsharesvalue(rshares): conv = Converter() rew_bal = float( Amount(steem.steemd.get_reward_fund()['reward_balance']).amount) rec_claim = float(steem.steemd.get_reward_fund()['recent_claims']) steemvalue = rshares * rew_bal / rec_claim return conv.steem_to_sbd(steemvalue)
def update(): """Update witness properties.""" c = get_config() c['witness']['url'] = click.prompt( 'What should be your witness URL?', default=c['witness']['url'], ) creation_fee = click.prompt( 'How much do you want the account creation fee to be (STEEM)?', default=c['props']['account_creation_fee'], ) if silent(float)(creation_fee): creation_fee = "%s STEEM" % float(creation_fee) c['props']['account_creation_fee'] = str(Amount(creation_fee)) c['props']['maximum_block_size'] = click.prompt( 'What should be the maximum block size?', default=c['props']['maximum_block_size'], ) c['props']['sbd_interest_rate'] = click.prompt( 'What should be the SBD interest rate?', default=c['props']['sbd_interest_rate'], ) # verify output(c, '\nConfiguration') click.confirm('Do you want to commit the updated values?', abort=True) # update set_config(c) witness_set_props(c['witness']['url'], c['props']) output('Witness %s Updated' % c['witness']['name'])
def global_props(self): ''' Retrieves the global properties used to determine rates used for calculations in converting steempower to vests etc. Stores these in the Utilities class as that is where the conversions take place, however SimpleSteem is the class that contains steem_instance, so to to preserve heirarchy and to avoid "spaghetti code", this method exists in this class. ''' if self.util.info is None: self.util.info = self.steem_instance().get_dynamic_global_properties() self.util.total_vesting_fund_steem = Amount(self.util.info["total_vesting_fund_steem"]).amount self.util.total_vesting_shares = Amount(self.util.info["total_vesting_shares"]).amount self.util.vote_power_reserve_rate = self.util.info["vote_power_reserve_rate"] return self.util.info
def getvotevalue(SP, VotingPower, VotingWeight): """Calculates the SBD value of a vote. Args: SP: The Steem Power value. VotingPower: The Voting Power value, percentage from 0-100. VotingWeight: The Voting Weight, percentage from 0-100. Returns: the upvote value in SBD. """ POWER = SP / (float(Amount(steem.steemd.get_dynamic_global_properties()['total_vesting_fund_steem']).amount) \ / float(steem.steemd.get_dynamic_global_properties()['total_vesting_shares'].rstrip(' VESTS'))) VOTING = ((100 * VotingPower * (100 * VotingWeight) / 10000) + 49) / 50 REW = float(Amount(steem.steemd.get_reward_fund()['reward_balance']).amount) \ / float(steem.steemd.get_reward_fund()['recent_claims']) PRICE = float(Amount(steem.steemd.get_current_median_history_price()['base']).amount) \ / float(Amount(steem.steemd.get_current_median_history_price()['quote']).amount) VoteValue = (POWER * VOTING * 100) * REW * PRICE return VoteValue
def getvoteweight(SP, VoteValue, VotingPower): """Calculates the Vote Weight needed to achieve a specific upvote value. Args: SP: The Steem Power value. VotingValue: SBD value to achieve. VotingPower: The Voting Power value, percentage from 0-100. Returns: the Voting Weight, percentage from 0-100. """ POWER = SP / (float(Amount(steem.steemd.get_dynamic_global_properties()['total_vesting_fund_steem']).amount) \ / float(steem.steemd.get_dynamic_global_properties()['total_vesting_shares'].rstrip(' VESTS'))) REW = float(Amount(steem.steemd.get_reward_fund()['reward_balance']).amount) \ / float(steem.steemd.get_reward_fund()['recent_claims']) PRICE = float(Amount(steem.steemd.get_current_median_history_price()['base']).amount) \ / float(Amount(steem.steemd.get_current_median_history_price()['quote']).amount) VOTING = VoteValue / (POWER * 100 * REW * PRICE) VotingWeight = ((VOTING * 50 - 49) * 10000) / (100 * 100 * VotingPower) return VotingWeight
def worth_sp(self): s = get_steem_conn() info = state.load_state() p = 10000 sp = self.total_sp # steem power vp = 100 # voting power vw = 100 # voting weight tvf = Amount(info['total_vesting_fund_steem']).amount tvs = Amount(info['total_vesting_shares']).amount r = float(sp / (tvf / tvs)) m = float(100 * vp * (100 * vw) / p) m = float((m + 49) / 50) quote = Amount(s.get_current_median_history_price()['quote']).amount base = Amount(s.get_current_median_history_price()['base']).amount o = base / quote rb = Amount(s.get_reward_fund('post')['reward_balance']).amount rc = float(s.get_reward_fund('post')['recent_claims']) i = rb / rc return "%.4f" % (r * m * 100 * i * o)
def fetch_tag(self, tag, start_author=None, start_permlink=None, posts=[], scanned_pages=0): logger.info("Fetching tag: #%s", tag) query = { "limit": 100, "tag": tag, } if start_author: query.update({ "start_author": start_author, "start_permlink": start_permlink, }) post_list = list( self.steemd_instance.get_discussions_by_created(query)) for post in post_list: created_at = parse(post["created"]) if (datetime.utcnow() - created_at).days > 5: return posts # Check if post age is older than MINIMUM_POST_AGE (IN MINUTE!) elapsed_minutes = (datetime.utcnow() - created_at).total_seconds() // 60 if self.config.get("MINIMUM_POST_AGE_MIN"): if self.config.get("MINIMUM_POST_AGE_MIN") > elapsed_minutes: continue if self.config.get("MAXIMUM_POST_REWARDS"): pending_payout = Amount(post.get("pending_payout_value")) if pending_payout.amount > self.config.get( "MAXIMUM_POST_REWARDS"): continue posts.append(post) if scanned_pages > 100 or len(posts) > 50: logger.info("%s posts found at #%s tag.", len(posts), tag) return posts if not len(post_list): logger.info("No article Found with this tag") return posts return self.fetch_tag( tag, start_author=post["author"], start_permlink=post["permlink"], posts=posts, scanned_pages=scanned_pages + 1, )
def detail(full_address): detail = {} author, permlink = full_address.split("/")[4:] post = steem.get_content(author.replace("@", ""), permlink) detail["payout"] = Amount(post["pending_payout_value"]).amount * 0.56 * 0.5 detail["net_votes"] = post["net_votes"] detail["votes"] = [ i["voter"] for i in steem.get_active_votes(author.replace("@", ""), permlink) ] return detail
def compute_total_sbd(upvote_payments): sbd = 0 steem = 0 for (author, permalink), payments in upvote_payments.items(): for payment in payments.values(): amount = Amount(payment['amount']) value = amount.amount asset = amount.asset if asset == 'SBD': sbd += value elif asset == 'STEEM': steem += value return sbd, steem
def calculate_producer_rewards(steemd_instance, witness_account): account = Account(witness_account, steemd_instance=steemd_instance) total_vests = 0 for producer_reward in account.history_reverse( filter_by=["producer_reward"]): total_vests += Amount(producer_reward["vesting_shares"]).amount converter = Converter(steemd_instance=s) total_sp = converter.vests_to_sp(total_vests) return total_vests, total_sp
def getrsharesvalue(rshares): """Converts a vote's rshares value to current SBD value. Args: rshares: the rshares value of an upvote. Returns: the current SBD upvote value. """ conv = Converter() rew_bal = float(Amount(steem.steemd.get_reward_fund()['reward_balance']).amount) rec_claim = float(steem.steemd.get_reward_fund()['recent_claims']) steemvalue = rshares * rew_bal / rec_claim return conv.steem_to_sbd(steemvalue)
def delegations(username): if username.startswith("@"): username = username.replace("@", "") s = get_steem_conn() account = Account(username, s).set_account_deta() outgoing_delegations = s.get_vesting_delegations(username, 0, 100) eight_days_ago = datetime.utcnow() - timedelta(days=8) expiring_delegations = s.get_expiring_vesting_delegations( username, eight_days_ago.strftime("%Y-%m-%dT%H:%M:%S"), 1000) info = state.load_state() outgoing_delegations_fixed = [] for outgoing_delegation in outgoing_delegations: created_at = parse(outgoing_delegation["min_delegation_time"]) amount = Amount(outgoing_delegation["vesting_shares"]).amount outgoing_delegation.update({ "min_delegation_time": created_at, "sp": round(vests_to_sp(amount, info), 2), "vesting_shares": round(amount / 1e6, 4), }) outgoing_delegations_fixed.append(outgoing_delegation) expiring_delegations_fixed = [] for expiring_delegation in expiring_delegations: created_at = parse(expiring_delegation["expiration"]) amount = Amount(expiring_delegation["vesting_shares"]).amount expiring_delegation.update({ "expiration": created_at, "sp": round(vests_to_sp(amount, info), 2), "vesting_shares": round(amount / 1e6, 4), }) expiring_delegations_fixed.append(expiring_delegation) return render_template( "delegations.html", account=account, outgoing_delegations=outgoing_delegations_fixed, expiring_delegations=expiring_delegations, )
def compute_bidbot_correction(post_frame, upvote_payments, sbd_punishment_factor=2.2, steem_punishment_factor=2.0): post_frame['sbd_bought_reward'] = 0. post_frame['steem_bought_reward'] = 0. post_frame['bought_votes'] = 0 post_frame.set_index(['author', 'permalink'], inplace=True) for (author, permalink), payments in upvote_payments.items(): if (author, permalink) in post_frame.index: sbd = 0 steem = 0 votes = 0 for payment in payments.values(): amount = Amount(payment['amount']) value = amount.amount asset = amount.asset votes += 1 if asset == 'SBD': sbd += value elif asset == 'STEEM': steem += value else: raise RuntimeError('W00t?') post_frame.loc[ (author, permalink), ['sbd_bought_reward', 'steem_bought_reward', 'bought_votes' ]] = sbd, steem, votes post_frame.reset_index(inplace=True) post_frame['adjusted_reward'] = post_frame.reward - \ post_frame.sbd_bought_reward * sbd_punishment_factor - \ post_frame.steem_bought_reward * steem_punishment_factor post_frame.loc[post_frame.adjusted_reward < 0, 'adjusted_reward'] = 0 post_frame['adjusted_votes'] = post_frame.votes - post_frame.bought_votes post_frame.loc[post_frame.adjusted_votes < 0, 'adjusted_votes'] = 0 num_articles = (post_frame.bought_votes > 0).sum() percent = num_articles / len(post_frame) * 100 total_steem = post_frame.steem_bought_reward.sum() total_sbd = post_frame.sbd_bought_reward.sum() total_votes = post_frame.bought_votes.sum() logger.info('Found {} upvoted articles ({:.2f}%) with ' 'total {:.3f} STEEM {:.3f} SBD, and {} bought votes!'.format( num_articles, percent, total_steem, total_sbd, total_votes)) return post_frame