def main(): parser = argparse.ArgumentParser( description='show user balances', epilog='Report bugs to: https://github.com/bitfag/golos-scripts/issues' ) parser.add_argument('account', help='account name') parser.add_argument('-c', '--config', default='./common.yml', help='specify custom path for config file') args = parser.parse_args() # parse config with open(args.config, 'r') as ymlfile: conf = yaml.load(ymlfile) golos = Steem(nodes=conf['nodes_new'], no_broadcast=True) a = Account(args.account, steemd_instance=golos) b = a.get_balances() pprint(b) vests = b['total']['GESTS'] cv = Converter(golos) pprint('GP: {}'.format(cv.vests_to_sp(vests)))
def update_account(mongo, username, load_extras=True): """ Update Account. If load_extras is True, update: - followers, followings - curation stats - withdrawal routers, conversion requests """ a = Account(username) account = { **typify(a.export(load_extras=load_extras)), 'account': username, 'updatedAt': dt.datetime.utcnow(), } if type(account['json_metadata']) is dict: account['json_metadata'] = \ strip_dot_from_keys(account['json_metadata']) if not load_extras: account = {'$set': account} try: mongo.Accounts.update({'name': a.name}, account, upsert=True) except WriteError: # likely an invalid profile account['json_metadata'] = {} mongo.Accounts.update({'name': a.name}, account, upsert=True) print("Invalidated json_metadata on %s" % a.name)
def get_transactions(): id = "" bid ="" parameteraccount = "nextcolony" account = Account(parameteraccount) #this function is used to load transcations into a database account_history = list(account.get_account_history(-1, 10000, filter_by=["transfer"])) for transaction in account_history: try: memo = transaction["memo"] trx_id = transaction['trx_id'] timestamp =transaction['timestamp'] fromaccount = transaction["from"] if memo.startswith('nc'): #print (transaction) code, parameters = transaction["memo"].split("@") JSON = json.loads(parameters) #print(JSON) command = (JSON['command']) type = (JSON['type']) #print (type) #print (command) if type =="auctionbid": bid = command['bid'] id = command['id'] #print (id) #print (bid) #print (transaction) #write the transaction in the database # Connect to the database connection = pymysql.connect(host='localhost', user='******', password='******', db='steembattle', charset='utf8mb4', cursorclass=pymysql.cursors.DictCursor) with connection.cursor() as cursor: sql = ("SELECT * FROM `auction` WHERE `steem_trx` = '"+str(trx_id)+"'") #print(sql) cursor.execute(sql) results = cursor.fetchone() #print(results) if results == None: print ("Noch nicht vorhanden") with connection.cursor() as cursor: sql = ("INSERT INTO `auction` (`trx_id`, `steem_trx`, `timestamp`, `bid`, `planet_id`, `user`) VALUES (NULL, '"+str(trx_id)+"', '"+str(timestamp)+"', '"+str(bid)+"', '"+str(id)+"', '"+str(fromaccount)+"')") print(sql) cursor.execute(sql) connection.commit() connection.close() #print(JSON) except: continue return
def process_timestamp(self, block): timestamp = block['timestamp'] datetime_object = datetime.strptime(timestamp, '%Y-%m-%dT%H:%M:%S') if datetime_object.second == 54: account = Account(self.account) print(f'\nVoting power: {account.voting_power()}%\n') if account.voting_power() == 100: self.queue.run_voting_round()
def run(): account = "sttest1" account = Account(account) wif = os.environ.get("UNLOCK") steem = Steem(wif=wif) blockchain = Blockchain() stream = map(Post, blockchain.stream(filter_by=["comment"])) upvote_list = json.load(open('upvote_list.json')) upvoted = {} upvote_queue = {} date = int(time.strftime("%d")) hour = int(time.strftime("%-H")) print("Entering blockchain stream!") while True: try: for post in stream: time_string = str(post.time_elapsed()) post_age = time_string.split(":") try: # Omit posts older than 10 min if int(post_age[0]) > 0 or int(post_age[1]) > 10: break except Exception as e: #print (repr(e)) break # start upvoting cycle at 100% voting power if account.voting_power() == 100: start_upvote_cycle(upvote_queue, account, steem) # check for new date if int(time.strftime("%d")) is not date: upvoted = {} date = int(time.strftime("%d")) #check for new hour if int(time.strftime("%-H")) is not hour: upvote_list = json.load(open('upvote_list.json')) hour = int(time.strftime("%-H")) # verify post and add to queue if valid_post(post, upvote_list, upvoted): try: author = post["author"] print ("\nAdding to queue{}\nPermlink: {}".format(author, post['identifier'])) if post['identifier'] not in upvote_queue: upvote_queue[post['identifier']] = upvote_list[author]["upvote_weight"] print ("Upvoted {} for {}%".format(author, upvote_list[author]["upvote_weight"])) upvoted[author] += 1 except Exception as error: print(repr(error)) continue except Exception as error: #print(repr(error)) continue
def get_history(self, username): a = Account(username) history = a.history_reverse() count = 1 for item in history: if count > 3: break print(item) count = count + 1
def get_inbound_steem_transfers(account_name): nodes = ['https://api.steemit.com', 'https://gtg.steem.house:8090'] set_shared_steemd_instance(Steemd(nodes=nodes)) acc = Account('greenman') def filter(t): return t['to'] == account_name and float( t['amount'].split(' ')[0]) > .1 return [t for t in acc.history(filter_by=['transfer']) if filter(t)]
class Testcases(unittest.TestCase): def __init__(self, *args, **kwargs): super(Testcases, self).__init__(*args, **kwargs) self.account = Account(testaccount) def test_readAccount(self): self.assertEqual(self.account["id"], 1489) def test_getbalance(self): self.account.get_balances()
def get_latest_flags(self): flags = {} total_amount = 0 account = Account(self.account_for_flag_report, steemd_instance=self.steemd_instance) for vote in account.history_reverse(filter_by="vote"): if vote["weight"] > 0: continue if vote["voter"] != self.account_for_flag_report: continue ts = parse(vote["timestamp"]) if ts < (datetime.utcnow() - timedelta(days=1)): break try: p = Post("%s/%s" % (vote["author"], vote["permlink"]), steemd_instance=self.steemd_instance) except steembase.exceptions.PostDoesNotExist: logger.info("Couldnt load the post. %s" % vote["permlink"]) continue if vote["author"] not in flags: flags[vote.get("author")] = { "posts": 0, "comments": 0, "total_removed": 0 } if p.is_main_post(): flags[vote.get("author")].update( {"posts": flags[vote.get("author")]["posts"] + 1}) else: flags[vote.get("author")].update( {"comments": flags[vote.get("author")]["comments"] + 1}) logger.info("Analyzing %s" % self.url(p)) for active_vote in p.get("active_votes"): if float(active_vote.get("rshares")) > 0: continue if active_vote.get("voter") != self.account_for_flag_report: continue amount_removed = self.get_payout_from_rshares( active_vote.get("rshares")) total_amount += amount_removed flags[vote.get("author")].update({ "total_removed": flags[vote.get("author")]["total_removed"] + amount_removed, }) return flags, round(total_amount, 2)
def handle_curation(self, op_type, op_value): curators = [c["account"] for c in get_curators()] # we're only interested in votes if op_type != "vote": return # if the voter is not a trusted curator, skip it. if op_value.get("voter") not in curators: return # check the post if we have already voted? p = Post("%s/%s" % (op_value.get("author"), op_value.get("permlink")), steemd_instance=self.s) # we're only interested in main posts if not p.is_main_post(): return # the post is tagged with the tags we defined? if len(set(self.expected_tags).intersection(p.get("tags"))) == 0: return # is the author in the blacklist? if is_blacklisted(op_value.get("author")): return score = 0 already_voted = False curators_on_the_post = [] for active_vote in p.get("active_votes", []): if active_vote.get("voter") == self.bot_account: already_voted = True if active_vote.get("voter") in curators: score += active_vote.get("percent") curators_on_the_post.append({ "curator": active_vote.get("voter"), "weight": active_vote.get("percent"), }) # if we already voted on that, skip. if already_voted: return # if the score is lower then the threshold, skip. if score < int(get_option(THRESHOLD_OPTION_ID)["value"]): return bot_account = Account(self.bot_account, steemd_instance=self.s) weight = bot_account.voting_power() self.upvote(p, weight, self.bot_account) self.post_to_webhooks(p, curators_on_the_post, score, weight)
def run(tags): log.info("Follow mode activated", tags=tags) if tags is None or len(tags) < 1: raise ValueError("You must specify at least one tag") log.debug("initializing...") steem = Steem(keys=[cred.key]) account = Account(cred.id, steem) chain = Blockchain(steem) log.debug("ready", steem=steem, account=account, blockchain=chain) log.info("Gathering our following list...") following = account.get_following() pending = [] log.info("Following list retrieved", count=len(following)) log.info("Watching for new posts...") while True: stream = map(Post, chain.stream(filter_by=['comment'])) try: for post in stream: count = len(pending) if count > 0: copy = list(pending) for i in range(count): if have_bandwidth(steem, account): user = copy[i] log.info("following user", user=user) steem.follow(user, account=cred.id) del pending[0] else: log.warn("Waiting for more bandwidth before following another user") break if post.is_main_post(): log.debug("found a top-level post", author=post.author, tags=post.tags) if post.author != cred.id: for tag in tags: if tag in post.tags: if post.author not in following: pending.append(post.author) following.append(post.author) break except PostDoesNotExist as e: log.debug("Post has vanished", exception=e) except RPCError as e: log.error("RPC problem while streaming posts", exception=e)
def update_account(mongo, steem, username, load_extras=True): """ Update Account. If load_extras """ a = Account(username, steem_instance=steem) account = { **typify(a.export(load_extras=load_extras)), 'account': username, 'updatedAt': dt.datetime.utcnow(), } if not load_extras: account = {'$set': account} mongo.Accounts.update({'name': a.name}, account, upsert=True)
def test_history(): a = Account('barbara2') h1 = [x['index'] for x in list(a.history())] h2 = [x['index'] for x in list(a.history_reverse())] # pprint(list(zip(h1, h2[::-1]))) # various tests of equality should pass assert len(h1) == len(h2) assert set(h1) == set(h2) == set(range(a.virtual_op_count() + 1)) assert h1 == h2[::-1] == list(range(a.virtual_op_count() + 1))
def __init__(self, account_name, steem_instance=None): if not steem_instance: steem_instance = stm.Steem() self.steem = steem_instance self.account = Account(account_name) self.current_index = self.account.virtual_op_count() self.history = None # prevent duplicates self.seen_items = set()
def voting_stats(account_name): # Get voting statistics given an account name. # Returns Steem Power, Voting Power, Time to recharge(min), Current Voting Power and Value of vote in Steem account = Account(account_name) SP = steemfunc.calculateSP(account) print('Steem Power:', int(SP), 'SP') VP,recharge_time = steemfunc.getactiveVP(account) current_VP = account.voting_power() print('Voting Power:', int(VP)) vote_value = steemfunc.getvotevalue(SP, VP, 100) return SP,VP,recharge_time,current_VP,vote_value
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 last_voted_accounts_and_posts(self): voted_accounts = set() voted_posts = set() account = Account(self.config.get("BOT_ACCOUNT")) vote_interval = self.config.get("VOTE_INTERVAL_IN_DAYS", 1) for vote in account.history_reverse(filter_by=["vote"]): created_at = parse(vote["timestamp"]) if created_at < (datetime.utcnow() - timedelta(days=vote_interval)): break voted_accounts.add(vote["author"]) voted_posts.add("@%s/%s" % (vote["author"], vote["permlink"])) return voted_accounts, voted_posts
def processComment(op): comment_body = op['body'] if not comment_body or comment_body.startswith('@@ '): return post = Post(op, steem_instance=steem) pkey = getPostKey(post) print('post: ', pkey) if not pkey or pkey in processed_posts: return processed_posts[pkey] = True author_account = Account(op['author'], steem_instance=steem) if author_account.rep < MIN_NOTIFY_REPUTATION: # no notifications for low-rep accounts return processMentions(author_account, comment_body, op) if op['parent_author']: if op['parent_author'] != op['author']: # no need to notify self of own comments title = 'Steemit' body = '@%s replied to your post or comment' % (op['author']) url = '%s/@%s/recent-replies' % ( os.environ['STEEMIT_WEBCLIENT_ADDRESS'], op['parent_author']) profile = author_account.profile pic = img_proxy_prefix + profile['profile_image'] \ if profile and 'profile_image' in profile else '' tnt_server.call('notification_add', op['parent_author'], NTYPES['comment_reply'], title, body, url, pic) else: followers = getFollowers(author_account) for follower in followers: tnt_server.call('notification_add', follower, NTYPES['feed'])
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 __init__(self, username): self.username = username self.session = Account(self.username, steemd_instance=s) self.wallet = { "steem_balance": float(self.session['balance'].replace('STEEM', '')), "sbd_balance": float(self.session['sbd_balance'].replace('SBD', '')), "vests": float(self.session['vesting_shares'].replace('VESTS', '')), "delegated_vests": float(self.session['received_vesting_shares'].replace('VESTS', '')) - float(self.session['delegated_vesting_shares'].replace( 'VESTS', '')), "delegated_vesting_shares": float(self.session['delegated_vesting_shares'].replace( 'VESTS', '')), "received_vesting_shares": float(self.session['received_vesting_shares'].replace('VESTS', '')), "voting_power": float(self.session['voting_power'] / 100) } self.wallet['acc_value'] = self.calculate_estimated_acc_value() self.wallet['upvote'] = self.calculate_estimated_upvote() self.wallet['delegations'] = self.calculate_steem_power( )['delegations'] self.wallet['sp_balance'] = self.calculate_steem_power()['sp_balance']
def create(self, community_type: str = 'public', admins: Union[str, list] = None): """ Create a new community. This method will upgrade an existing STEEM account into a new community. Args: community_type: Can be **public** (default) or **restricted**. admins: A single username, or a list of users who will be community Admins. If left empty, the community owner will be assigned as a single admin. Can be modified later. """ # validate account and community name Account(self.account) assert self.community == self.account, 'Account name and community name need to be the same' if is_community(self.community): raise NameError( 'Can not create community %s, because it already exists.' % self.community) if type(admins) == str: admins = [admins] if not admins: admins = [self.community] op = self._op(action='create', type=community_type, admins=admins) return self._commit(op)
def commitParticipants(): current = Account(donation_account) current_participants = current['json_metadata']['extensions']['ico'] if state != current_participants: l("Committing participants to `json_metadata` on @{}".format( donation_account)) saveState()
def getsbdprice(): #get the last transactions of steemmonsters from the blockchain acc = Account('steemmonsters') account_history = acc.get_account_history(-1, 1000, filter_by=["custom_json"]) for custom_json in account_history: try: data = custom_json["json"] parsed_json = json.loads(data) code = custom_json["id"] if code == "sm_price_feed": sbd = parsed_json["sbd"] return (sbd) except: print("Error getting the SBD price")
def update_account_ops(mongo, username): """ This method will fetch entire account history, and back-fill any missing ops. """ for event in Account(username).history(): with suppress(DuplicateKeyError): transform = compose(strip_dot_from_keys, remove_body, json_expand, typify) mongo.AccountOperations.insert_one(transform(event))
def update_account(name): account = Account(name).export(load_extras=False) prepare_account(account) # TODO Parse coordinates # parse_location(account) AccountModel.objects(name=name).update(**account, upsert=True)
def saveState(): current = Account(donation_account) profile = current['json_metadata'] if 'extensions' not in profile: profile.update({'extensions': {'ico': {}}}) if 'ico' not in profile['extensions']: profile['extensions'].update({'ico': {}}) profile['extensions']['ico'] = state s.update_account_profile(profile, account=donation_account)
def create_json(): user_json = {} for user in Account(username).export()["following"]: user_json[user] = { "upvote_weight": 100.0, "upvote_limit": 2, "upvote_count": 0 } return user_json
def addFollower(account_name, follower): print('addFollower', account_name, follower) res = tnt_server.call('add_follower', account_name, follower) if not res[0][0]: with suppress(Exception): followers = getFollowersWithDirection(Account(account_name)) followers.append(follower) followers_space.insert((account_name, followers)) tnt_server.call('add_follower', account_name, follower)
def create_json(): user_json = {} for user in Account("runburgundy").export()["following"]: user_json[user] = { "upvote_weight": 100.0, "upvote_limit": 2, "upvote_count": 0 } print(user_json) return user_json
def get_current_vp(username, steemd): account = Account(username, steemd_instance=steemd) last_vote_time = parse(account["last_vote_time"]) diff_in_seconds = (datetime.utcnow() - last_vote_time).total_seconds() regenerated_vp = diff_in_seconds * 10000 / 86400 / 5 total_vp = (account["voting_power"] + regenerated_vp) / 100 if total_vp > 100: total_vp = 100 return total_vp
def get_fill_vesting_withdraw(): all_transactions = Account(steem_username, steem).get_account_history( -1, INT_steem_limit, filter_by='fill_vesting_withdraw', raw_output=True) for data in all_transactions: DICT_details = data[1] trx_id = DICT_details.get("trx_id") block = DICT_details.get("block") trx_in_block = DICT_details.get("trx_in_block") op_in_trx = DICT_details.get("op_in_trx") virtual_op = DICT_details.get("virtual_op") timestamp = DICT_details.get("timestamp") human_time = datetime.datetime.strptime(timestamp, '%Y-%m-%dT%H:%M:%S') LIST_op = DICT_details.get("op") DICT_op = LIST_op[1] from_account = DICT_op.get("from_account") to_account = DICT_op.get("to_account") withdrawn = DICT_op.get("withdrawn") deposited = DICT_op.get("deposited") # Generate link to block link = "https://steemworld.org/block/" + str(block) filled = "" value = check_exists_transaction("fill_vesting_withdraw", human_time, "timestamp") if value is True: continue sql_insert = (""" INSERT INTO fill_vesting_withdraw (trx_id, block, trx_in_block, op_in_trx, virtual_op, timestamp, from_account, to_account, withdrawn, deposited, link, filled) VALUES("%s","%s","%s","%s","%s","%s","%s","%s","%s","%s","%s", "%s"); """) % (str(trx_id), str(block), str(trx_in_block), str(op_in_trx), str(virtual_op), str(human_time), str(from_account), str(to_account), str(withdrawn), str(deposited), str(link), str(filled)) cursor.execute(sql_insert) mariadb_connection.commit() return