def transfer_to_someone(key, token, name, toplayer, money, memo): local_values.s = Steem(keys=[key]) contract_payload = { 'symbol': token, 'to': toplayer, 'quantity': str(money), 'memo': memo } json_data = { 'contractName': 'tokens', 'contractAction': 'transfer', 'contractPayload': contract_payload } kk = local_values.s.custom_json('ssc-mainnet1', json_data, required_auths=[name]) tx = Signed_Transaction(kk) tx.data.pop("signatures", None) print(tx) h = hashlib.sha256(bytes(tx)).digest() transaction_id = hexlify(h[:20]).decode("ascii") print(transaction_id) url = "https://steemd.com/tx/%s" % transaction_id print(url) print("转账完成") return url
def benchmark_calls(node, authorpermvoter, num_retries=10, num_retries_call=10, timeout=60): block_count = 0 history_count = 0 access_time = timeout follow_time = 0 sucessfull = False error_msg = None start_total = timer() account_name = "gtg" [author, permlink, voter] = resolve_authorpermvoter(authorpermvoter) authorperm = construct_authorperm(author, permlink) try: stm = Steem(node=node, num_retries=num_retries, num_retries_call=num_retries_call, timeout=timeout) start = timer() Vote(authorpermvoter, steem_instance=stm) stop = timer() vote_time = stop - start start = timer() c = Comment(authorperm, steem_instance=stm) if c.title == '': raise AssertionError("title must not be empty!") stop = timer() comment_time = stop - start start = timer() acc = Account(author, steem_instance=stm) # if acc.json()["json_metadata"] == '': # raise AssertionError("json_metadata must not be empty!") stop = timer() account_time = stop - start sucessfull = True access_time = (vote_time + comment_time + account_time) / 3.0 except NumRetriesReached: error_msg = 'NumRetriesReached' sucessfull = False except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) sucessfull = False total_duration = float("{0:.2f}".format(timer() - start_total)) access_time = float("{0:.3f}".format(access_time)) return { 'sucessfull': sucessfull, 'node': node, 'error': error_msg, 'total_duration': total_duration, 'access_time': access_time, 'count': None }
def rpc(self) -> Steem: if not self._rpc: # Use the symbol of the first coin for our settings. symbol = list(self.all_coins.keys())[0] _settings = self.all_coins[symbol].settings['json'] rpcs = _settings.get('rpcs', settings.HIVE_RPC_NODES) # If you've specified custom RPC nodes in the custom JSON, make a new instance with those # Otherwise, use the global shared_steem_instance. rpc_conf = dict(num_retries=5, num_retries_call=3, timeout=20, node=rpcs) log.info('Getting BSteem instance for coin %s - settings: %s', symbol, rpc_conf) self._rpc = Steem(node=rpcs, **rpc_conf) if empty(rpcs, itr=True) else Steem(**rpc_conf) # type: Steem self._rpc.set_password_storage(_settings.get('pass_store', 'environment')) self._rpcs[symbol] = self._rpc return self._rpc
def profiling(name_list): stm = Steem() set_shared_steem_instance(stm) del stm print("start") for name in name_list: print("account: %s" % (name)) acc = Account(name) max_index = acc.virtual_op_count() print(max_index) stopTime = datetime(2018, 4, 22, 0, 0, 0) hist_elem = None for h in acc.history_reverse(stop=stopTime): hist_elem = h print(hist_elem) print("blockchain") blockchain_object = Blockchain() current_num = blockchain_object.get_current_block_num() startBlockNumber = current_num - 20 endBlockNumber = current_num block_elem = None for o in blockchain_object.ops(start=startBlockNumber, stop=endBlockNumber): print("block %d" % (o["block_num"])) block_elem = o print(block_elem)
def get_rpc(self, symbol: str) -> Steem: """ Returns a Steem instance for querying data and sending TXs. By default, uses the Beem shared_steem_instance. If a custom RPC list is specified in the Coin "custom json" settings, a new instance will be returned with the RPCs specified in the json. :param symbol: Coin symbol to get Beem RPC instance for :return beem.steem.Steem: An instance of :class:`beem.steem.Steem` for querying """ if symbol not in self._rpcs: settings = self.settings[symbol]['json'] rpcs = settings.get('rpcs') rpc_conf = dict(num_retries=5, num_retries_call=3, timeout=20, node=rpcs, custom_chains=custom_chains) log.info('Getting Beem instance for coin %s - settings: %s', symbol, rpc_conf) self._rpcs[symbol] = self.rpc if empty(rpcs, itr=True) else Steem( **rpc_conf) self._rpcs[symbol].set_password_storage( settings.get('pass_store', 'environment')) return self._rpcs[symbol]
def setup(self): self.prefix = u"STEEM" self.default_prefix = u"STM" self.wif = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3" self.ref_block_num = 34294 self.ref_block_prefix = 3707022213 self.expiration = "2016-04-06T08:29:27" self.stm = Steem(offline=True)
def daili(key, player, toplayer, sp): local_values.s = Steem(keys=[key]) acc = Account(player, steem_instance=local_values.s) resp = acc.delegate_vesting_shares(toplayer, local_values.s.sp_to_vests(sp), account=player) print(resp)
def calculate_shares(): global reward_share, base_share, reward_vesting, steem_per_mvest try: info = Steem().get_dynamic_global_properties() reward_fund = Steem().get_reward_funds() total_vests = Amount(info["total_vesting_shares"]).amount total_vesting_fund = Amount(info["total_vesting_fund_steem"]).amount reward_balance = Amount(reward_fund["reward_balance"]).amount recent_claims = float(reward_fund["recent_claims"]) reward_share = reward_balance / recent_claims base_share = Amount( Steem().get_current_median_history()["base"]).amount reward_vesting = total_vesting_fund / total_vests steem_per_mvest = Steem().get_steem_per_mvest() print("- Reward Share and Base Share Actualized") except Exception as err: print("*Error Calculate Shares : %s" % err) pass return
def get_steem_instance(self, config, keys=None): if not keys: keys = [] logger.info("Connecting to the blockchain using mainnet.") nodes = config.get("NODES") or [ "https://api.hive.blog", "https://api.hivekings.com", "https://anyx.io" ] steem = Steem(node=nodes, keys=keys, custom_chains=custom_chains) return steem
def get_rpc(self, symbol): """ Returns a Steem instance for querying data and sending TXs. By default, uses the Beem shared_steem_instance. If a custom RPC list is specified in the Coin "custom json" settings, a new instance will be returned with the RPCs specified in the json. :param symbol: Coin symbol to get Beem RPC instance for :return beem.steem.Steem: An instance of :class:`beem.steem.Steem` for querying """ rpc_list = self.settings[symbol]['json'].get('rpcs') return self.rpc if empty(rpc_list, itr=True) else Steem(node=rpc_list)
def __init__(self, symbol: str): super().__init__(symbol) settings = self.coin.settings['json'] rpcs = settings.get('rpcs') # If you've specified custom RPC nodes in the custom JSON, make a new instance with those # Otherwise, use the global shared_steem_instance. self.rpc = shared_steem_instance() if empty(rpcs, itr=True) else Steem( rpcs) # type: Steem self.rpc.set_password_storage(settings.get('pass_store', 'environment')) # Internal storage variables for the properties ``asset`` and ``precisions`` self._asset = self._precision = None
async def stream(): try: stm = Steem(node=[ "https://api.steemit.com", "https://steemd.minnowsupportproject.org", "https://anyx.io" ]) chain = Blockchain(stm, "head") for tx in chain.stream(['custom_json']): if tx['id'] == 'sm_sell_cards': user_perm_posting = "" user_perm_active = "" try: user_perm_posting = tx['required_posting_auths'][0] except: pass try: user_perm_active = tx['required_auths'][0] except: pass json_data = json.loads(tx['json']) loop.create_task( process(json_data, user_perm_posting, user_perm_active)) elif tx['id'] == 'sm_update_price': market_id_list = json.loads(tx['json'])['ids'] card_uid_dict = [] for market_id in market_id_list: time.sleep(2) try: response_json = requests.get( f"https://steemmonsters.com/market/status?id={market_id}" ).json() card_uid = response_json['cards'][0]['uid'] card_uid_dict.append(card_uid) except: pass user_perm_posting = "" user_perm_active = "" try: user_perm_posting = tx['required_posting_auths'][0] except: pass try: user_perm_active = tx['required_auths'][0] except: pass loop.create_task( process(card_uid_dict, user_perm_posting, user_perm_active)) await asyncio.sleep(0) except: print(traceback.format_exc())
def __init__(self, symbol: str): super().__init__(symbol) settings = self.coin.settings['json'] rpcs = settings.get('rpcs') # If you've specified custom RPC nodes in the custom JSON, make a new instance with those # Otherwise, use the global shared_steem_instance. self.rpc = shared_steem_instance() if empty(rpcs, itr=True) else Steem( rpcs) # type: Steem self.rpc.set_password_storage(settings.get('pass_store', 'environment')) # For easy reference, the Beem asset object, and precision self.asset = asset = Asset(self.symbol) self.precision = int(asset.precision)
def custom_beem(node: Union[str, list] = "", *args, **kwargs): """ Override the beem Steem instance (:py:attr:`._steem`) used by this class. Useful if you'd rather not configure beem's shared instance for some reason. Example usage: >>> from privex.steemengine import SteemEngineToken >>> SteemEngineToken.custom_beem(node=['https://steemd.privex.io', 'https://api.steemit.com']) """ from beem.steem import Steem SteemEngineToken._steem = Steem(node, *args, **kwargs) return SteemEngineToken._steem
def benchmark_node_history(node, num_retries=10, num_retries_call=10, timeout=60, how_many_seconds=60, account_name="gtg"): history_count = 0 access_time = 0 follow_time = 0 sucessfull = False error_msg = None start_total = timer() start_time = timer() try: stm = Steem(node=node, num_retries=num_retries, num_retries_call=num_retries_call, timeout=timeout) account = Account(account_name, steem_instance=stm) start_time = timer() for acc_op in account.history_reverse(batch_size=100): history_count += 1 if not sucessfull: sucessfull = True if timer() - start_time > how_many_seconds or quit_thread: break except NumRetriesReached: error_msg = 'NumRetriesReached' sucessfull = False except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' sucessfull = False # quit = True except Exception as e: error_msg = str(e) sucessfull = False total_duration = float("{0:.2f}".format(timer() - start_time)) return { 'sucessfull': sucessfull, 'node': node, 'error': error_msg, 'total_duration': total_duration, 'count': history_count, 'access_time': None }
def get_config_node(node, num_retries=10, num_retries_call=10, timeout=60, how_many_seconds=30): blockchain_version = u'0.0.0' is_hive = False sucessfull = True error_msg = None access_time = timeout config = {} start_total = timer() try: stm = Steem(node=node, num_retries=num_retries, num_retries_call=num_retries_call, timeout=timeout) blockchain_version = stm.get_blockchain_version() is_hive = stm.is_hive start = timer() config = stm.get_config(use_stored_data=False) stop = timer() access_time = stop - start config_count = 0 except NumRetriesReached: error_msg = 'NumRetriesReached' sucessfull = False except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) total_duration = float("{0:.2f}".format(timer() - start_total)) access_time = float("{0:.2f}".format(access_time)) ret = { 'sucessfull': sucessfull, 'node': node, 'error': error_msg, 'total_duration': total_duration, 'count': None, 'access_time': access_time, 'version': blockchain_version, 'config': config, 'is_hive': is_hive } return ret
def steem_sbd(key, player, token, mymoney, toplayer, memo): local_values.s = Steem(keys=[key]) set_shared_steem_instance(local_values.s) account = Account(player) # 转账 kk = account.transfer(toplayer, mymoney, token, memo) tx = Signed_Transaction(kk) tx.data.pop("signatures", None) print(tx) h = hashlib.sha256(bytes(tx)).digest() transaction_id = hexlify(h[:20]).decode("ascii") print(transaction_id) url = "https://steemd.com/tx/%s" % transaction_id print("转账完成") print(url) return url
def anyx(): SV = os.environ.get('SV') di = { '16': .55, '15': .03, '5': .42, '49': .45, '27': .42, '38': .42, '70': .50, '71': .45, '72': .55, '73': .45, '74': .4, } dic = {'16': .7, '5': .50, '49': .7, '27': .56, '38': .68} stm = Steem(node="https://anyx.io", keys=SV) acc = Account('sourovafrin', steem_instance=stm) bo = Blockchain(stm, 'head') print("started anyx") for detail in bo.stream(['custom_json']): try: if detail['id'] == 'sm_sell_cards': for i in ast.literal_eval(detail['json']): lin = requests.get( "https://steemmonsters.com/cards/find?ids=" + i['cards'][0]).json() for ii in lin: id = ii['market_id'] idd = str(ii['card_detail_id']) price = float(ii['buy_price']) if int(ii['edition']) == 1 and price <= di[idd]: acc.transfer( 'svirus', 2, 'SBD', "sm_market_purchase:" + id + ":sourovafrin") elif int(ii['edition']) == 0 and price <= dic[idd]: acc.transfer( 'svirus', 2, 'SBD', "sm_market_purchase:" + id + ":sourovafrin") except Exception as e: print("Error found anyx: {}".format(e))
def main(conn, logger, debug=False): # Main Loop s = Steem(node=nodes) theChain = Blockchain(steem_instance=s, mode="head") Start_block_num = read_blocknum_fromfile("virtual_ops_block.txt") if not Start_block_num: Start_block_num = theChain.get_current_block_num() # print('Start For loop') try: for block in theChain.stream(only_virtual_ops=True, start=Start_block_num): print("Try add to DB") addblock_to_db(block, conn, logger) except Exception as e: return
def main(conn, logger, debug=False): s = Steem(node=nodes) theChain = Blockchain(steem_instance=s, mode="head") # print('Start For loop') Start_block_num = read_blocknum_fromfile("ops_block.txt") if not Start_block_num: Start_block_num = theChain.get_current_block_num() try: for block in theChain.stream(start=Start_block_num): # print("Run Again") # print(f"{block['block_num']}") yay = addblock_to_db(block, conn, logger) # print("Got out ok") except Exception as e: logger.error(f"Error in Stream: {e}") return
def profiling(node, name_list, shared_instance=True, clear_acc_cache=False, clear_all_cache=True): print("shared_instance %d clear_acc_cache %d clear_all_cache %d" % (shared_instance, clear_acc_cache, clear_all_cache)) if not shared_instance: stm = Steem(node=node) print(str(stm)) else: stm = None acc_dict = {} for name in name_list: acc = Account(name, steem_instance=stm) acc_dict[name] = acc if clear_acc_cache: acc.clear_cache() acc_dict = {} if clear_all_cache: clear_cache() if not shared_instance: del stm.rpc
if __name__ == "__main__": how_many_minutes = 10 how_many_virtual_op = 10000 max_batch_size = None threading = False thread_num = 16 nodes = get_node_list(appbase=False) + get_node_list(appbase=True) t = PrettyTable([ "node", "10 blockchain minutes", "10000 virtual account op", "version" ]) t.align = "l" for node in nodes: print("Current node:", node) try: stm = Steem(node=node, num_retries=3) blockchain = Blockchain(steem_instance=stm) account = Account("gtg", steem_instance=stm) virtual_op_count = account.virtual_op_count() blockchain_version = stm.get_blockchain_version() last_block_id = 19273700 last_block = Block(last_block_id, steem_instance=stm) startTime = datetime.now() stopTime = last_block.time() + timedelta(seconds=how_many_minutes * 60) ltime = time.time() cnt = 0 total_transaction = 0
from beemgraphenebase.account import PasswordKey, PrivateKey, PublicKey from beem.steem import Steem from beem.utils import parse_time, formatTimedelta from beemapi.exceptions import NumRetriesReached from beem.nodelist import NodeList log = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) password = "******" username = "******" useWallet = False walletpassword = "******" if __name__ == "__main__": testnet_node = "https://testnet.steem.vc" stm = Steem(node=testnet_node) prefix = stm.prefix # curl --data "username=username&password=secretPassword" https://testnet.steem.vc/create if useWallet: stm.wallet.wipe(True) stm.wallet.create(walletpassword) stm.wallet.unlock(walletpassword) active_key = PasswordKey(username, password, role="active", prefix=prefix) owner_key = PasswordKey(username, password, role="owner", prefix=prefix) posting_key = PasswordKey(username, password, role="posting", prefix=prefix) memo_key = PasswordKey(username, password, role="memo", prefix=prefix) active_pubkey = active_key.get_public_key() owner_pubkey = owner_key.get_public_key() posting_pubkey = posting_key.get_public_key() memo_pubkey = memo_key.get_public_key() active_privkey = active_key.get_private_key()
accountname = 'bitcoinjake09' myPlanet = "P-Z6AY2BGWNIO" shipName = "corvette" shipCount = 3 sleepAmt = ( (3244) * 2 ) #set as (time it takes ships to get to planet + 4 seconds for steem blockchain) *2 for total mission # can use a seconds calculator if you know your ships time from spycolony distance calculator: # https://spycolony.herokuapp.com/calc.html # seconds calculator: https://www.dollartimes.com/calculators/hours-minutes-calculator.htm count = 1 # Address of person I don't like x/y x = -24 y = 249 while (count <= 1001): s = Steem(node=nodes, keys=[PK]) id = 'nextcolony' json_data = { "username": accountname, "type": "attack", "command": { "tr_var1": { shipName: { "pos": 1, "n": shipCount } }, "tr_var2": x, "tr_var3": y, "tr_var4": myPlanet }
def benchmark_node_blocks(node, num_retries=10, num_retries_call=10, timeout=60, how_many_seconds=30): block_count = 0 sucessfull = False error_msg = None start_total = timer() start_time = timer() max_batch_size = None threading = False thread_num = 16 last_block_id = 19273700 try: stm = Steem(node=node, num_retries=num_retries, num_retries_call=num_retries_call, timeout=timeout) blockchain = Blockchain(steem_instance=stm) last_block_id = int(blockchain.get_current_block_num() * 0.75) last_block = Block(last_block_id, steem_instance=stm) total_transaction = 0 start_time = timer() for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num): block_no = entry.identifier block_count += 1 if not sucessfull: sucessfull = True if "block" in entry: trxs = entry["block"]["transactions"] else: trxs = entry["transactions"] for tx in trxs: for op in tx["operations"]: total_transaction += 1 if "block" in entry: block_time = (entry["block"]["timestamp"]) else: block_time = (entry["timestamp"]) if timer() - start_time > how_many_seconds or quit_thread: break except NumRetriesReached: error_msg = 'NumRetriesReached' sucessfull = False except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) sucessfull = False total_duration = float("{0:.2f}".format(timer() - start_time)) return { 'sucessfull': sucessfull, 'node': node, 'error': error_msg, 'total_duration': total_duration, 'count': block_count, 'access_time': None }
def benchmark_block_diff(node, num_retries=10, num_retries_call=10, timeout=60): block_count = 0 history_count = 0 access_time = timeout follow_time = 0 sucessfull = False error_msg = None start_total = timer() block_diff = 0 block_head_diff = 0 try: stm = Steem(node=node, num_retries=num_retries, num_retries_call=num_retries_call, timeout=timeout) b = Blockchain(steem_instance=stm) b_head = Blockchain(mode="head", steem_instance=stm) dhi_max = 0 head_max = timedelta(0) for i in range(0, 5): utcnow = addTzInfo(datetime.utcnow()) df_head = addTzInfo( datetime.utcnow()) - b_head.get_current_block()["timestamp"] diff_value = b_head.get_current_block_num( ) - b.get_current_block_num() if diff_value > dhi_max: dhi_max = diff_value if df_head > head_max: head_max = df_head time.sleep(3) block_head_diff = head_max.total_seconds() block_diff = dhi_max sucessfull = True except NumRetriesReached: error_msg = 'NumRetriesReached' sucessfull = False except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) sucessfull = False total_duration = float("{0:.2f}".format(timer() - start_total)) block_diff = float("{0:.2f}".format(block_diff)) block_head_diff = float("{0:.2f}".format(block_head_diff)) return { 'sucessfull': sucessfull, 'node': node, 'error': error_msg, 'total_duration': total_duration, 'access_time': None, 'count': None, 'diff_head_irreversible': block_diff, 'head_delay': block_head_diff }
from beembase import operations from beem.transactionbuilder import TransactionBuilder from beemgraphenebase.account import PasswordKey, PrivateKey, PublicKey from beem.steem import Steem from beem.utils import parse_time, formatTimedelta from beemapi.exceptions import NumRetriesReached from beem.nodelist import NodeList from beembase.transactions import getBlockParams log = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) # example wif wif = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3" if __name__ == "__main__": stm_online = Steem() ref_block_num, ref_block_prefix = getBlockParams(stm_online) print("ref_block_num %d - ref_block_prefix %d" % (ref_block_num, ref_block_prefix)) stm = Steem(offline=True) op = operations.Transfer({ 'from': 'beembot', 'to': 'holger80', 'amount': "0.001 SBD", 'memo': "" }) tb = TransactionBuilder(steem_instance=stm) tb.appendOps([op])
from datetime import date, datetime, timedelta from io import StringIO from pprint import pprint import requests from beem.steem import Steem from beem.wallet import Wallet from pandas import read_csv from sqlalchemy import create_engine logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s", datefmt="%m/%d/%Y %I:%M:%S %p") wif = os.environ["STEEM_WIF"] stm = Steem(node="https://api.steemit.com", keys=wif, nobroadcast=False) w = Wallet(blockchain_instance=stm) author = w.getAccountFromPrivateKey(wif) logging.debug(author) engine = create_engine("sqlite:///covid.db") covid_cvs = requests.get( "https://opendata.ecdc.europa.eu/covid19/casedistribution/csv") yesterday = datetime.now() + timedelta(days=-1) covid_day = yesterday.strftime("%d/%m/%Y") df = read_csv(StringIO(covid_cvs.text)) sql = df.to_sql("Covid", con=engine, if_exists="replace") result = engine.execute(f'SELECT * FROM Covid where dateRep="{covid_day}"') data = result.fetchall() def main():
from __future__ import division from __future__ import print_function from __future__ import unicode_literals from builtins import int, str import sys from datetime import timedelta import time import io from beem.steem import Steem import logging from prettytable import PrettyTable log = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) if __name__ == "__main__": stm = Steem(node="https://api.steemit.com") # stm = Steem(node="https://testnet.steemitdev.com") # stm = Steem(node="wss://appbasetest.timcliff.com") # stm = Steem(node="https://api.steemitstage.com") # stm = Steem(node="https://api.steemitdev.com") all_calls = stm.rpc.get_methods(api="jsonrpc") t = PrettyTable(["method", "args", "ret"]) t.align = "l" t_condenser = PrettyTable(["method", "args", "ret"]) t_condenser.align = "l" for call in all_calls: if "condenser" not in call: ret = stm.rpc.get_signature({'method': call}, api="jsonrpc") t.add_row([call, ret['args'], ret['ret']]) else: ret = stm.rpc.get_signature({'method': call}, api="jsonrpc")
######### # Steem Network related settings #### from privex.helpers import env_csv # Supply a list of one or more comma-separated Steem RPC nodes. If not set, will use the default beem nodes. STEEM_RPC_NODES = env_csv('STEEM_RPC_NODES', None) # Supply a list of one or more comma-separated Steem RPC nodes. If not set, will use the default beem nodes. HIVE_RPC_NODES = env_csv('HIVE_RPC_NODES', [ 'https://anyx.io', 'https://hived.privex.io', 'https://hived.hive-engine.com' ]) # Set the shared Beem RPC instance to use the specified nodes steem_ins = Steem(node=STEEM_RPC_NODES, num_retries=5, num_retries_call=3, timeout=20) steem_ins.set_password_storage( 'environment') # Get Beem wallet pass from env var ``UNLOCK`` set_shared_steem_instance(steem_ins) # Set the shared Beem RPC instance to use the specified nodes # hive_ins = Hive(node=HIVE_RPC_NODES, num_retries=5, num_retries_call=3, timeout=20) # hive_ins.set_password_storage('environment') # Get Beem wallet pass from env var ``UNLOCK`` # set_shared_hive_instance(hive_ins) ######### # SteemEngine Handler Network related settings #### SENG_NETWORK_ACCOUNT = env('SENG_NETWORK_ACCOUNT', 'ssc-mainnet1')