def take_offer(self, data): bitshares = BitShares(nobroadcast=False, keys=data['key'], blocking='head') trade_message = '' new_data = {} if data['market_or_pool'] == 'pool': new_data['operation_type'] = 'Pool Operation' if data['buy_or_sell'] == 'buy': amount_to_sell = Amount(data['expected_price']) new_data['anticipated'] = Amount('{} {}'.format(data['amount_to_buy_sell'], data['selected_asset'])) min_to_receive = new_data['anticipated'] * .993 trade_message = bitshares.exchange_with_liquidity_pool( pool=data['pool_id'], amount_to_sell=amount_to_sell, min_to_receive=min_to_receive, account=data['account'], ) else: amount_to_sell = Amount('{} {}'.format(data['amount_to_buy_sell'], data['selected_asset'])) new_data['anticipated'] = Amount(data['expected_price']) min_to_receive = new_data['anticipated'] * .993 trade_message = bitshares.exchange_with_liquidity_pool( pool=data['pool_id'], amount_to_sell=amount_to_sell, min_to_receive=min_to_receive, account=data['account'], ) new_data['operation_results'] = trade_message['operation_results'] new_data['paid'] = Amount(new_data['operation_results'][0][1]['paid'][0]) new_data['received'] = Amount(new_data['operation_results'][0][1]['received'][0]) # still not working quite right else: # market trade pass pub.sendMessage('print_transaction', data=new_data)
def deposit_lp(self, data): trade_message = '' new_data = {} try: bitshares = BitShares(nobroadcast=False, keys=data['key'], blocking='head') trade_message = bitshares.deposit_into_liquidity_pool( pool=data['poolshare_symbol'], amount_a=Amount( data['asset_x_amount'], data['asset_x_symbol'], ), amount_b=Amount( data['asset_y_amount'], data['asset_y_symbol'], ), account=data['account'], ) new_data['operation_results'] = trade_message['operation_results'] except Exception as err: print(err) if new_data: try: new_data['paid_x'] = Amount(new_data['operation_results'][0][1]['paid'][0]) new_data['paid_y'] = Amount(new_data['operation_results'][0][1]['paid'][1]) new_data['received'] = Amount(new_data['operation_results'][0][1]['received'][0]) pub.sendMessage('print_deposit', data=new_data) except: print('error parsing deposit operation results') else: print('deposit operation failed')
def withdraw_lp(self, data): trade_message = '' new_data = {} try: bitshares = BitShares(nobroadcast=False, keys=data['key'], blocking='head') trade_message = bitshares.withdraw_from_liquidity_pool( pool=data['asset'], share_amount=Amount( data['withdraw_amount'], data['asset'], ), account=data['account'], ) new_data['operation_results'] = trade_message['operation_results'] except Exception as err: print(err) if new_data: try: new_data['paid'] = Amount(new_data['operation_results'][0][1]['paid'][0]) new_data['received_x'] = Amount(new_data['operation_results'][0][1]['received'][0]) new_data['received_y'] = Amount(new_data['operation_results'][0][1]['received'][1]) pub.sendMessage('print_withdraw', data=new_data) except: print('error parsing withdraw operation results') else: print('withdraw operation failed')
def test_gateway_handler(self): bitshares = BitShares(settings.BITSHARES_NODE_URL, nobroadcast=settings.BLOCKCHAIN_NOBROADCAST, keys=[settings.BITSHARES_GATEWAY_WIF]) bitshares.set_default_account(settings.BITSHARES_GATEWAY_ACCOUNT) transnet = Transnet(settings.TRANSNET_NODE_URL, nobroadcast=settings.BLOCKCHAIN_NOBROADCAST, keys={ 'active': settings.TRANSNET_GATEWAY_WIF, 'memo': settings.TRANSNET_GATEWAY_WIF_MEMO }) transnet.set_default_account(settings.TRANSNET_GATEWAY_ACCOUNT) transaction = BitsharesTransnetTransaction.objects.create( trx_id='test', trx_in_block=3, op_in_trx=3, asset='UTECH.UTCORE', amount=pow(10, 5), account_external='superpchelka23', account_internal='superpchelka23') handler = BitsharesGatewayHandler(bitshares, settings.BITSHARES_GATEWAY_ACCOUNT, transnet, settings.TRANSNET_GATEWAY_ACCOUNT, settings.TRANSNET_GATEWAY_WIF_MEMO, {'UTECH.UTCORE': 'UTECH.UTCORE'}) handler.handle([transaction], lambda: True) self.assertTrue(transaction.closed, 'Transaction must be properly processed')
def reconnect(BitPAIR, USERNAME, PASS_PHRASE): # create fresh websocket connection connected = 0 while not connected: # fetch fresh nodes list from subprocess and shuffle it nds = race_read('nodes.txt') if isinstance(nds, list): nodes = nds shuffle(nodes) node = nodes[0] try: account = Account(USERNAME, bitshares_instance=BitShares(node, num_retries=0)) market = Market(BitPAIR, bitshares_instance=BitShares(node, num_retries=0), mode='head') chain = Blockchain( bitshares_instance=BitShares(node, num_retries=0), mode='head') if chain.get_network()['chain_id'] != ID: raise ValueError('Not Mainnet Chain') connected = 1 except: pass try: market.bitshares.wallet.unlock(PASS_PHRASE) except: pass return account, market, nodes, chain
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.bts = BitShares("wss://node.testnet.bitshares.eu", nobroadcast=True, keys={"active": wif}) set_shared_bitshares_instance(self.bts) self.bts.set_default_account("init0")
class Testcases(unittest.TestCase): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.bts = BitShares( "wss://node.testnet.bitshares.eu", nobroadcast=True, # We want to bundle many operations into a single transaction bundle=True, # Overwrite wallet to use this list of wifs only wif={"active": wif} ) self.bts.set_default_account("init0") set_shared_bitshares_instance(self.bts) def test_account(self): Account("witness-account") Account("1.2.3") asset = Asset("1.3.0") symbol = asset["symbol"] account = Account("witness-account", full=True) self.assertEqual(account.name, "witness-account") self.assertEqual(account["name"], account.name) self.assertEqual(account["id"], "1.2.1") self.assertIsInstance(account.balance("1.3.0"), Amount) # self.assertIsInstance(account.balance({"symbol": symbol}), Amount) self.assertIsInstance(account.balances, list) for h in account.history(limit=1): pass # BlockchainObjects method account.cached = False self.assertTrue(account.items()) account.cached = False self.assertIn("id", account) account.cached = False self.assertEqual(account["id"], "1.2.1") self.assertEqual(str(account), "<Account 1.2.1>") self.assertIsInstance(Account(account), Account) def test_account_upgrade(self): account = Account("witness-account") tx = account.upgrade() ops = tx["operations"] op = ops[0][1] self.assertEqual(len(ops), 1) self.assertEqual( getOperationNameForId(ops[0][0]), "account_upgrade" ) self.assertTrue( op["upgrade_to_lifetime_member"] ) self.assertEqual( op["account_to_upgrade"], "1.2.1", )
def balances_bit_shares(config, secrets_json, source, scopeTickers): printSource = '' # this is cleaner than passing printSource as a param. if not config.VERBOSE: printSource = source+"\n " # VERBOSE already printed it. from bitshares import BitShares amounts = BitShares(config, secrets_json['account']) for key, value in amounts.items(): if not scopeTickers or key in scopeTickers: printBalance(printSource, key, value) printSource = ' ' try: # bitshares.account will work under Python3, but throw exception if Python2 from bitshares.account import Account account = Account(secrets_json['account']) print (account.json()) # We add the balances and open-orders amounts, since we still own unfilled open-orders amounts = { } for balance in account.balances: ticker = balance.symbol.replace('BRIDGE.','') if ticker not in amounts: amounts[ticker] = 0 amounts[ticker] += balance.amount for openorder in account.openorders: order = openorder['base'] ticker = order.symbol.replace('BRIDGE.','') if ticker not in amounts: amounts[ticker] = 0 amounts[ticker] += order.amount for key, value in amounts.items(): if not scopeTickers or key in scopeTickers: printBalance(printSource, key, value) printSource = ' ' return '' except KeyboardInterrupt as ex: raise KeyboardInterrupt() except: ex = sys.exc_info()[0] if config.VERBOSE: print( "Exception in balances.balances_bit_shares(): "+str(ex), file=sys.stderr ) proc = subprocess.Popen(['/opt/mining/mining/balances/bit-shares.py', source], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) out, err = proc.communicate(None) if err: print(err,file=sys.stderr) return out = out.decode('utf-8') lines = out.splitlines() # "[0.00001017 BRIDGE.BTC, 162.1362 BRIDGE.RVN]" line = lines[0].replace('[','').replace(']','') vals = line.split(", ") for val in vals: val_coin = val.split(' ') value = val_coin[0] ticker = val_coin[1].replace('BRIDGE.','') if not scopeTickers or ticker in scopeTickers: #print(' '+ticker + " " + value) printBalance(printSource, ticker, float(value.replace(',',''))) printSource = ' '
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.bts = BitShares( "wss://node.testnet.bitshares.eu", nobroadcast=True, ) self.bts.set_default_account("init0") set_shared_bitshares_instance(self.bts) self.chain = Blockchain(mode="head")
def dex_withdraw(): # undeveloped definition for withdrawals from bitshares import BitShares bitshares = BitShares() bitshares.wallet.unlock("wallet-passphrase") bitshares.transfer(to=send_to, amount=send_amount, asset=BTS, memo=None, account=account)
def test_default_connection2(self): b1 = BitShares("wss://node.testnet.bitshares.eu", nobroadcast=True) test = Asset("1.3.0", blockchain_instance=b1) test.refresh() b2 = BitShares("wss://node.bitshares.eu", nobroadcast=True) bts = Asset("1.3.0", blockchain_instance=b2) bts.refresh() self.assertEqual(test["symbol"], "TEST") self.assertEqual(bts["symbol"], "X4T")
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.bts = BitShares( nobroadcast=True, # We want to bundle many operations into a single transaction bundle=True, # Overwrite wallet to use this list of wifs only wif=[wif]) self.bts.set_default_account("init0") set_shared_bitshares_instance(self.bts)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.bts = BitShares( "wss://node.testnet.bitshares.eu", nobroadcast=True, keys={"active": wif}, ) # from getpass import getpass # self.bts.wallet.unlock(getpass()) set_shared_bitshares_instance(self.bts) self.bts.set_default_account("init0")
def test_bts1bts2(self): b1 = BitShares( "wss://node.testnet.bitshares.eu", nobroadcast=True, ) b2 = BitShares( "wss://node.bitshares.eu", nobroadcast=True, ) self.assertNotEqual(b1.rpc.url, b2.rpc.url)
def reconnect(): global account, market, nodes, chain, pings try: history_text.delete("1.0", "end") history_text.insert(END, '\n\n CONNECTING...') master.update() except: pass print(cyan(time.ctime() + ' CONNECTING...')) start = time.time() # create fresh websocket connection connected = 0 while not connected: # fetch fresh nodes list from subprocess and shuffle it metaNODE = Bitshares_Trustless_Client() nds = metaNODE['whitelist'] del metaNODE if isinstance(nds, list): nodes = nds shuffle(nodes) node = nodes[0] print(green(node)) pings = [0] try: account = Account(USERNAME, bitshares_instance=BitShares(nodes, num_retries=2)) market = Market(BitPAIR, bitshares_instance=BitShares(nodes, num_retries=2), mode='head') chain = Blockchain(bitshares_instance=BitShares(nodes, num_retries=2), mode='head') if chain.get_network()['chain_id'] != ID: raise ValueError('Not Mainnet Chain') connected = 1 except Exception as e: try: history_text.insert(END, '\n\n RECONNECTING...') master.update() except: pass msg = (time.ctime() + str(type(e).__name__) + str(e.args)) print('RECONNECTING ' + msg) pass try: market.bitshares.wallet.unlock(PASS_PHRASE) except: # print('YOUR WALLET IS LOCKED') pass print('CONNECTION ELAPSED: ', ('%.1f' % (time.time() - start)))
def __init__(self): self.site_settings = SettingsModel.load() self.bitshares = BitShares( self.site_settings.bitshares_transnet_node_url, nobroadcast=settings.BLOCKCHAIN_NOBROADCAST, keys={ 'active': self.site_settings.bitshares_transnet_active_wif, }, ) self.bitshares.set_default_account( self.site_settings.bitshares_transnet_gateway_address) super(BitsharesBasedGateway, self).__init__()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.bts = BitShares(nobroadcast=True, wif=[wif]) set_shared_bitshares_instance(self.bts) self.bts.set_default_account("init0") cache = ObjectCache(default_expiration=5, no_overwrite=True) init0 = { 'active': { 'account_auths': [], 'address_auths': [], 'key_auths': [[str(PrivateKey(wif).pubkey), 1]], 'weight_threshold': 1 }, 'active_special_authority': [0, {}], 'blacklisted_accounts': [], 'blacklisting_accounts': [], 'cashback_vb': '1.13.102', 'id': '1.2.90742', 'lifetime_referrer': '1.2.90742', 'lifetime_referrer_fee_percentage': 8000, 'membership_expiration_date': '1969-12-31T23:59:59', 'name': 'init0', 'network_fee_percentage': 2000, 'options': { 'extensions': [], 'memo_key': str(PrivateKey(wif).pubkey), 'num_committee': 0, 'num_witness': 0, 'votes': [], 'voting_account': '1.2.5' }, 'owner': { 'account_auths': [], 'address_auths': [], 'key_auths': [[str(PrivateKey(wif).pubkey), 1]], 'weight_threshold': 1 }, 'owner_special_authority': [0, {}], 'referrer': '1.2.90742', 'referrer_rewards_percentage': 0, 'registrar': '1.2.90742', 'statistics': '2.6.90742', 'top_n_control_flags': 0, 'whitelisted_accounts': [], 'whitelisting_accounts': [] } cache[init0["id"]] = init0 cache[init0["name"]] = init0 BlockchainObject._cache = cache
def publish_price(account, price): btsNode = 'wss://node.testnet.bitshares.eu' bitshares = BitShares(btsNode, account.name, account.pwd) price = float(price) stlprice = Price(price, "TEST/" + account.asset, bitshares_instance=bitshares) btsAccount = Account(account.name, bitshares_instance=bitshares) bitshares.wallet.unlock(wallet_pwd) bitshares.publish_price_feed(account.asset, stlprice, account=btsAccount) bitshares.wallet.lock()
def test_default_connection(self): b1 = BitShares("wss://node.testnet.bitshares.eu", nobroadcast=True) set_shared_bitshares_instance(b1) test = Asset("1.3.0", blockchain_instance=b1) # Needed to clear cache test.refresh() b2 = BitShares("wss://node.bitshares.eu", nobroadcast=True) set_shared_bitshares_instance(b2) bts = Asset("1.3.0", blockchain_instance=b2) # Needed to clear cache bts.refresh() self.assertEqual(test["symbol"], "TEST") self.assertEqual(bts["symbol"], "BTS")
def main(): parser = argparse.ArgumentParser(description='', epilog='Report bugs to: ') parser.add_argument('-d', '--debug', action='store_true', help='enable debug output'), parser.add_argument('-c', '--config', default='./config.yml', help='specify custom path for config file') parser.add_argument('account') args = parser.parse_args() # create logger if args.debug == True: log.setLevel(logging.DEBUG) else: log.setLevel(logging.INFO) handler = logging.StreamHandler() formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s") handler.setFormatter(formatter) log.addHandler(handler) # parse config with open(args.config, 'r') as ymlfile: conf = yaml.safe_load(ymlfile) bitshares = BitShares(node=conf['node_bts'], no_broadcast=True) w = Witness(args.account, bitshares_instance=bitshares) pprint(dict(w))
def new_func(ctx, *args, **kwargs): ctx.bitshares = BitShares(ctx.config["node"], num_retries=-1, expiration=60, **ctx.obj) set_shared_bitshares_instance(ctx.bitshares) return ctx.invoke(f, *args, **kwargs)
def run(): # testnet = BitShares("wss://node.testnet.bitshares.eu") testnet = BitShares("ws://this.uptick.rocks:18090") account = Account("committee-account", full=True, bitshares_instance=testnet) proposals = account["proposals"] client = GrapheneAPI("localhost", 8092, "", "") for proposal in proposals: pprint(proposal) if click.confirm("Approve proposal %s" % proposal["id"]): # Get current fees core_asset = client.get_asset("1.3.0") committee_account = client.get_account("committee-account") proposal = client.get_object(proposal["id"])[0] prop_op = proposal["proposed_transaction"]["operations"] tx = client.approve_proposal( "faucet", proposal["id"], {"active_approvals_to_add": [ "committee-member-1", "committee-member-2", "committee-member-3", "committee-member-4", "committee-member-5", "committee-member-6", "committee-member-7", "committee-member-8", "committee-member-9", "committee-member-10"] }, True) pprint(tx)
def new_func(ctx, *args, **kwargs): ctx.bitshares = BitShares( ctx.config["node"], **ctx.obj ) set_shared_bitshares_instance(ctx.bitshares) return ctx.invoke(f, *args, **kwargs)
def __init__(self, *args, **kwargs): super(Testcases, self).__init__(*args, **kwargs) bitshares = BitShares( "wss://node.bitshares.eu", nobroadcast=True, ) set_shared_bitshares_instance(bitshares)
def ping(n, num, arr): # ping the blockchain and return latency try: start = time.time() chain = Blockchain(bitshares_instance=BitShares(n, num_retries=0), mode='head') # print(n,chain.rpc.chain_params["chain_id"]) ping_latency = time.time() - start current_block = chain.get_current_block_num() blocktimestamp = abs( chain.block_timestamp(current_block)) # + utc_offset) block_latency = time.time() - blocktimestamp # print (blocktimestamp) # print (time.time()) # print (block_latency) # print (ping_latency) # print (time.ctime()) # print (utc_offset) # print (chain.get_network()) if chain.get_network()['chain_id'] != ID: num.value = 333333 elif block_latency < (ping_latency + 4): num.value = ping_latency else: num.value = 111111 except: num.value = 222222 pass
def new_func(ctx, *args, **kwargs): newoptions = ctx.obj newoptions.update(kwargsChain) ctx.bitshares = BitShares(**newoptions) ctx.blockchain = ctx.bitshares set_shared_bitshares_instance(ctx.bitshares) return ctx.invoke(f, *args, **kwargs)
def bitshares(self) -> BitShares: """Returns an instance of BitShares and caches it in the attribute _bitshares after creation""" if not self._bitshares: self._bitshares = BitShares(settings.BITSHARES_RPC_NODE, bundle=True, keys=[]) return self._bitshares
def remove_offline_worker(config, worker_name): # Initialize the base strategy to get control over the data bitshares_instance = BitShares(config['node']) strategy = BaseStrategy(worker_name, config, bitshares_instance=bitshares_instance) strategy.purge()
def test_default_connection(self): b1 = BitShares("wss://eu.nodes.bitshares.ws", nobroadcast=True) set_shared_bitshares_instance(b1) test = Asset("1.3.0", blockchain_instance=b1) # Needed to clear cache test.refresh() """
def order_and_cancel(): cybex_config(node_rpc_endpoint=NODE_WS_ENDPOINT, chain_id=CHAIN_ID) net = BitShares(node=NODE_WS_ENDPOINT, **{'prefix': 'CYB'}) unlock(net) try: net.wallet.addPrivateKey('your active private key') except Exception as e: pass net.wallet.unlock('your wallet unlock password') account = Account('account name', bitshares_instance=net) market = Market(base=Asset('CYB'), quote=Asset('JADE.ETH'), bitshares_instance=net) # buy 0.001 JADE.ETH at price JADE.ETH:CYB 1000, expire in 60 seconds # market.sell will do the sell operation market.buy(1000, 0.001, 60, False, 'account name', 'Head') # query open orders for order in account.openorders: base_amount = order['base'].amount base_symbol = order['base'].symbol quote_amount = order['quote'].amount quote_symbol = order['quote'].symbol order_number = order['id'] print('{}:{}--{}/{}'.format(quote_symbol, base_symbol, quote_amount, base_amount)) # cancel order market.cancel(order_number, 'account name')
def tapbasic(referrer): # test is request has 'account' key if not request.json or 'account' not in request.json: abort(400) account = request.json.get('account', {}) # make sure all keys are present required_files = set( (config.get("require_fields", []) or []) + ["active_key", "memo_key", "owner_key", "name"] ) for required in required_files: if str(required) not in account: return api_error("Please provide '{}'".format(required)) # prevent massive account registration if request.headers.get('X-Real-IP'): ip = request.headers.get('X-Real-IP') else: ip = request.remote_addr if ( config.get("restrict_ip", True) and ip != "127.0.0.1" and models.Accounts.exists(ip) ): return api_error("Only one account per IP") # Check if account name is cheap name if ( config.get("disable_premium_names", True) and is_premiumname(account["name"]) ): return api_error("Only cheap names allowed!") # This is not really needed but added to keep API-compatibility with Rails Faucet account.update({"id": None}) bitshares = BitShares( config.witness_url, nobroadcast=config.nobroadcast, keys=[config.wif] ) # See if the account to register already exists if not is_test_account(account["name"]): try: Account(account["name"], bitshares_instance=bitshares) return api_error("Account exists") except: pass # Registrar registrar = account.get("registrar", config.registrar) or config.registrar try: registrar = Account(registrar, bitshares_instance=bitshares) except: return api_error("Unknown registrar: %s" % registrar) # Referrer referrer = account.get("referrer", config.default_referrer) or config.default_referrer try: referrer = Account(referrer, bitshares_instance=bitshares) except: return api_error("Unknown referrer: %s" % referrer) referrer_percent = account.get("referrer_percent", config.referrer_percent) # Make sure to not broadcast this testing account if not bitshares.nobroadcast: if is_test_account(account["name"]): bitshares.nobroadcast = True else: bitshares.nobroadcast = False if "email" in account and account["email"]: try: models.Accounts.validate_email(account["email"]) except Exception as e: return api_error(str(e)) # Create new account try: tx = bitshares.create_account( account["name"], registrar=registrar["id"], referrer=referrer["id"], referrer_percent=referrer_percent, owner_key=account["owner_key"], active_key=account["active_key"], memo_key=account["memo_key"], proxy_account=config.get("proxy", None), additional_owner_accounts=config.get("additional_owner_accounts", []), additional_active_accounts=config.get("additional_active_accounts", []), additional_owner_keys=config.get("additional_owner_keys", []), additional_active_keys=config.get("additional_active_keys", []), ) except Exception as e: log.error(traceback.format_exc()) return api_error(str(e)) if not is_test_account(account["name"]): models.Accounts( account=account["name"], full_name=account.get("real_name", None), email=account.get("email", None), ip=ip ) reply = {"account": { "name": account["name"], "owner_key": account["owner_key"], "active_key": account["active_key"], "memo_key": account["memo_key"], "referrer": referrer["name"] }} if is_test_account(account["name"]): tx.pop("signatures", None) reply.update({"tx": tx}) return jsonify(reply)
def tapv2(name, owner, active, memo, referrer): # prevent massive account registration if request.remote_addr != "127.0.0.1" and \ models.Accounts.exists(request.remote_addr): return api_error("Only one account per IP") # Check if account name is cheap name if (not re.search(r"[0-9-]", name) and re.search(r"[aeiouy]", name)): return api_error("Only cheap names allowed!") bitshares = BitShares( config.witness_url, nobroadcast=config.nobroadcast, keys=[config.wif] ) try: Account(name, bitshares_instance=bitshares) return api_error("Account exists") except: pass # Registrar registrar = config.registrar try: registrar = Account(registrar, bitshares_instance=bitshares) except: return api_error("Unknown registrar: %s" % registrar) # Referrer if not referrer: referrer = config.default_referrer try: referrer = Account(referrer, bitshares_instance=bitshares) except: return api_error("Unknown referrer: %s" % referrer) referrer_percent = config.referrer_percent # Create new account try: bitshares.create_account( name, registrar=registrar["id"], referrer=referrer["id"], referrer_percent=referrer_percent, owner_key=owner, active_key=active, memo_key=memo, proxy_account=config.get("proxy", None), additional_owner_accounts=config.get( "additional_owner_accounts", []), additional_active_accounts=config.get( "additional_active_accounts", []), additional_owner_keys=config.get( "additional_owner_keys", []), additional_active_keys=config.get( "additional_active_keys", []), ) except Exception as e: log.error(traceback.format_exc()) return api_error(str(e)) models.Accounts(name, request.remote_addr) return jsonify({ "status": "Account created", "account": { "name": name, "owner_key": owner, "active_key": active, "memo_key": memo, }})