def publish_feed(witness, price_to_publish_in_usd, discount): print(price_to_publish_in_usd) # GETTING USD BTS PRICE USD:BTS price market = Market("BTS:USD") price = market.ticker()['baseSettlement_price'] print(price) price.invert() # invert to allow easier multiplication # BTS:USD price one_usd_bts = price priceinbts = float(price_to_publish_in_usd) * one_usd_bts['price'] pricempa = Price("{} BTS/GOLOS".format(priceinbts)) print(pricempa) #unlock wallet... market.bitshares.wallet.unlock("YOUR BITSHARES UPTICK WALLET UNLOCK CODE") (market.bitshares.publish_price_feed( symbol="GOLOS", settlement_price=pricempa, cer=pricempa * (1 / 1.2), mcr=175, account=witness, )) print("Published price feed: " + str(price_to_publish_in_usd) + " USD/GOL (-" + str(discount * 100) + "%) at " + time.ctime() + "\n")
def cancel(ctx, market, account): """ Cancel Orders in Mkt, (Eg: cancel USD/BTS --account name) :param ctx: context :param market: market e.g. USD/BTS :param account: name of your bitshares acct :return: Success or Fail message """ try: my_market = Market(market) ctx.bitshares.bundle = True my_market.cancel( [x["id"] for x in my_market.accountopenorders(account)], account=account) response = ctx.bitshares.txbuffer.broadcast() log.info(response) if response is not None: log.info( f'Cancelled all orders on Market: {market} for account: {account}' ) else: log.info(f'No orders to cancel! {market} for account: {account}') except bitshares.exceptions.AssetDoesNotExistsException: log.info(f"Asset does not exist: {market}") except graphenecommon.exceptions.AccountDoesNotExistsException: log.info(f"Account does not exist: {account}")
def orderbook(ctx, market): market = Market(market, bitshares_instance=ctx.bitshares) orderbook = market.orderbook() ta = {} ta["bids"] = PrettyTable(["quote", "base", "price"]) ta["bids"].align = "r" for order in orderbook["bids"]: ta["bids"].add_row([ str(order["quote"]), str(order["base"]), "{:f} {}/{}".format(order["price"], order["base"]["asset"]["symbol"], order["quote"]["asset"]["symbol"]), ]) ta["asks"] = PrettyTable([ "price", "base", "quote", ]) ta["asks"].align = "r" ta["asks"].align["price"] = "l" for order in orderbook["asks"]: ta["asks"].add_row([ "{:f} {}/{}".format(order["price"], order["base"]["asset"]["symbol"], order["quote"]["asset"]["symbol"]), str(order["base"]), str(order["quote"]) ]) t = PrettyTable(["bids", "asks"]) t.add_row([str(ta["bids"]), str(ta["asks"])]) click.echo(t)
def market_orderbook(market_pair: hug.types.text, api_key: hug.types.text, request, hug_timer=5): """Given a valid market pair (e.g. USD:BTS) and your desired orderbook size limit, output the market pair's orderbook (buy/sell order) information in JSON.""" if (check_api_token(api_key) == True): # Check the api key # API KEY VALID google_analytics(request, 'market_orderbook') try: target_market = Market(market_pair) except: # Market is not valid return {'valid_market': False, 'valid_key': True, 'took': float(hug_timer)} target_market_orderbook_data = target_market.orderbook(limit=50) return {'market_orderbook': target_market_orderbook_data, 'market': market_pair, 'valid_market': True, 'valid_key': True, 'took': float(hug_timer)} else: # API KEY INVALID! return {'valid_key': False, 'took': float(hug_timer)}
def fees(ctx, currency): """ List fees """ from bitsharesbase.operationids import getOperationNameForId from bitshares.market import Market market = Market("%s:%s" % (currency, "BTS")) ticker = market.ticker() if "quoteSettlement_price" in ticker: price = ticker.get("quoteSettlement_price") else: price = ticker.get("latest", 0) price.invert() chain = Blockchain(bitshares_instance=ctx.bitshares) feesObj = chain.chainParameters().get("current_fees") fees = feesObj["parameters"] t = [["Operation", "Type", "Fee", currency]] for fee in fees: for f in fee[1]: data = [ highlight(getOperationNameForId(fee[0])), detail(f), detail(Amount({"amount": fee[1].get(f, 0), "asset_id": "1.3.0"})), detail( price * Amount({"amount": fee[1].get(f, 0), "asset_id": "1.3.0"}) ), ] t.append(data) print_table(t)
def test_get_own_last_trade_taker_sell(base_account, ro_worker, other_worker): """Test for https://github.com/Codaone/DEXBot/issues/708.""" worker1 = ro_worker worker3 = base_account() market1 = Market(worker1.worker["market"]) # Fill worker's order from different account # Note this order is significantly bigger by amount and lower by price than worker's order sell_orders1 = worker1.get_own_sell_orders() to_buy = sell_orders1[0]['base']['amount'] * 1.5 buy_price = sell_orders1[0]['price'] * 1.2 log.debug('Buying {} @ {} by worker3 from worker1'.format( to_buy, buy_price)) tx = market1.buy(buy_price, to_buy, account=worker3) log.debug(tx) # Bot uses last own trade price and acts as a taker worker1.is_center_price_dynamic = True worker1.cp_from_last_trade = True worker1['bootstrapped'] = True time.sleep(1.1) worker1.check_orders() # Expect correct last trade result = worker1.get_own_last_trade() assert result['price'] == pytest.approx( buy_price, rel=(10**-worker1.market['base']['precision']))
def market_24hr_vol(market_pair: hug.types.text, api_key: hug.types.text, hug_timer=5): """Given a valid market_pair (e.g. USD:BTS), output their 24hr market volume in JSON.""" if (check_api_token(api_key) == True): # Check the api key # API KEY VALID try: target_market = Market(market_pair) except: # Market is not valid return { 'valid_market': False, 'valid_key': True, 'took': float(hug_timer) } return { 'market_volume_24hr': target_market.volume24h(), 'market': market_pair, 'valid_market': True, 'valid_key': True, 'took': float(hug_timer) } else: # API KEY INVALID! return {'valid_key': False, 'took': float(hug_timer)}
def mergeMarket_before(self, iso, pair, tag, start, stop): asset_a = pair[0] asset_b = pair[1] rpc = iso.bts.rpc if not self.subscribed: s_id = rpc.get_subscription_id() subs = rpc.subscribe_to_market(s_id, asset_a["id"], asset_b["id"]) self._s_id = s_id self._tags.append("!" + str(s_id)) self.subscribed = True from bitshares.market import Market self.market = Market(base=asset_b, quote=asset_a, blockchain_instance=iso.bts) orders = self.market.orderbook() if self.initfetch: trades = self.market.trades(limit=100, start=start, stop=stop) else: trades = iso.getMarketBuckets(self.market["base"], self.market["quote"], start=start, stop=stop) return ( orders, trades, )
def mergeMarket_before(self, iso, pair, tag): #iso._wait_online(timeout=3) # will raise exception #if not(iso.is_connected()): # raise Exception asset_a = pair[0] asset_b = pair[1] rpc = iso.bts.rpc if not self.subscribed: s_id = rpc.get_subscription_id() subs = rpc.subscribe_to_market(s_id, asset_a["id"], asset_b["id"]) self._s_id = s_id self._tags.append("!" + str(s_id)) self.subscribed = True from bitshares.market import Market self.market = Market(tag, bitshares_instance=iso.bts) orders = self.market.orderbook() trades = self.market.trades(limit=100, raw=True) return ( orders, trades, )
def __init__(self, sett, **kwargs): """ Инициализация класса, рынков и получение цены BTS :param set sett: настройки класса str quote - актив, стоимость которого считаем str base - актив, в котором считаем стоимость list additional_assets - дополнительные рынки для расчета, кроме BTS list usdt_assets - дополнительные рынки, стоимость которых равна стоимости актива base float base_depth - глубина расчета цены в стаканах в активе base float history_depth - глубина расчета цены совершенных сделок в активе base int price_precision - количество знаков после запятой, для отображения цен int orderbook_limit - максимальное количество сделок из стакана получаемое от ноды int history_limit - максимальное количество сделок получаемое из истории от ноды int history_period - максимальное количество дней, за которые берется история set viz_account - данные аккаунта для публикации в блокчейне VIZ """ self.sett = sett self.quote_market = Market(self.sett['quote'] + ':BTS') self.base_market = Market('BTS:' + self.sett['base']) book = self.base_market.orderbook(limit=1) self.price = {} self.price['BTS'] = (book['asks'][0]['price'] + book['bids'][0]['price']) / 2 self.bids = [] self.asks = []
def get_blockchain_info(self): try: data = {'pool': Pool(self.pool_id_or_sym, invert=self.invert)} data['pool_object'] = data['pool']['object'] data['pool_name'] = Asset(data['pool_object']['share_asset']).symbol data['asset_x'] = Asset(data['pool_object']['asset_a']) data['asset_y'] = Asset(data['pool_object']['asset_b']) data['amount_x'] = Amount(int(data['pool_object']['balance_a'])/10**data['asset_x'].precision, data['asset_x']) data['amount_y'] = Amount(int(data['pool_object']['balance_b'])/10**data['asset_y'].precision, data['asset_y']) self.amount_x = data['amount_x'] self.amount_y = data['amount_y'] data['market_ticker_object'] = Market( # python bitshares reverses base and quote base=data['asset_y'], quote=data['asset_x'] ).ticker() data['market_orderbook'] = Market( base=data['asset_y'], quote=data['asset_x'] ).orderbook(50) data['pool_invariant'] = int(data['pool_object']['virtual_value'])/(10**(data['asset_x'].precision + data['asset_y'].precision)) #print(f"Invariant: {data['pool_invariant']}") # python bitshares reverses base and quote data['price_xy'] = Price(base=data['amount_y'], quote=data['amount_x']) data['price_yx'] = Price(base=data['amount_x'], quote=data['amount_y']) pub.sendMessage('update_gui', data=data) except Exception as err: print('Invalid pool selected. Error: {}'.format(err)) pub.sendMessage('invalid_pool')
def get_usdt_orderbook(self): """ Функция для проверки ордеров в стаканах пар указанные в параметре self.sett['usdt_assets'] Функция получает из сети BitShares данные из всех стаканов указанных в параметре self.sett['usdt_assets'] и формирует выборку на основе этих данных. Результаты ее работы сохраняются в переменных класса self.bids и self.asks """ for asset in self.sett['usdt_assets']: market = Market(self.sett['quote'] + ':' + asset) book = market.orderbook( limit=self.sett['orderbook_limit'] ) for bid in book['bids']: amount = bid['base']['amount'] bid = Order( bid['quote'], Amount(amount / self.price['BTS'], 'BTS') ) if not self.create_bids([bid]): break for ask in book['asks']: amount = ask['base']['amount'] ask = Order( ask['quote'], Amount(amount / self.price['BTS'], 'BTS') ) if not self.create_asks([ask]): break
def market_ticker(market_pair: hug.types.text, api_key: hug.types.text, request, hug_timer=5): """Given a valid market pair, retrieve ticker data & output as JSON.""" if (check_api_token(api_key) == True): # Check the api key # API KEY VALID google_analytics(request, 'market_ticker') try: target_market = Market(market_pair) except: # Market is not valid return {'valid_market': False, 'valid_key': True, 'took': float(hug_timer)} target_market_ticker_data = target_market.ticker() return {'market_ticker': target_market_ticker_data, 'market': market_pair, 'valid_market': True, 'valid_key': True, 'took': float(hug_timer)} else: # API KEY INVALID! return {'valid_key': False, 'took': float(hug_timer)}
def run_hertz_function(): time_before = pendulum.now() # Getting the value of USD in BTS market = Market("USD:BTS") # Set reference market to USD:BTS price = market.ticker()[ "quoteSettlement_price"] # Get Settlement price of USD price.invert( ) # Switching from quantity of BTS per USD to USD price of one BTS. #Hertz variables: #Change only for alternative Algorithm Based Assets. hertz_reference_timestamp = "2015-10-13T14:12:24+00:00" # Bitshares 2.0 genesis block timestamp hertz_current_timestamp = pendulum.now().timestamp( ) # Current timestamp for reference within the hertz script hertz_amplitude = 0.14 # 14% fluctuating the price feed $+-0.14 (2% per day) hertz_period_days = 28 # Aka wavelength, time for one full SIN wave cycle. hertz_phase_days = 0.908056 # Time offset from genesis till the first wednesday, to set wednesday as the primary Hz day. hertz_reference_asset_value = 1.00 # $1.00 USD, not much point changing as the ratio will be the same. hertz_core_exchange_rate = 0.80 # Calculate the current value of Hertz in USD hertz_value = get_hertz_feed(hertz_reference_timestamp, hertz_current_timestamp, hertz_period_days, hertz_phase_days, hertz_reference_asset_value, hertz_amplitude) hertz = Price(hertz_value, "USD/HERTZ" ) # Limit the hertz_usd decimal places & convert from float. cg = CoinGeckoAPI() # Initialise coingecko bts_usd_coingecko = cg.get_price( ids='bitshares', vs_currencies='usd') # Price of BTS in USD from coingecko bts_usd_coingecko_value = Price(bts_usd_coingecko["bitshares"]["usd"], "USD/BTS") # Price format hertz_bts = bts_usd_coingecko_value.invert() * hertz.as_quote( "HERTZ") # Feed price hertz_cer = hertz_bts * hertz_core_exchange_rate # Some printed outputs #print("Price of HERTZ in USD: {}".format(hertz)) #print("Price of HERTZ in BTS: {}".format(hertz_bts)) #print("Price of BTS in USD: {}".format(bts_usd_coingecko_value)) #print("Price of USD in BTS: {}".format(bts_usd_coingecko_value.invert())) # Unlock the Bitshares wallet hertz.bitshares.wallet.unlock("LOCAL_WALLET_PASSWORD") """ Publish the price feed to the BTS DEX Make sure you change the 'account' before executing. Don't change any of the other values. """ pprint( hertz.bitshares.publish_price_feed( "HERTZ", hertz_bts, cer=hertz_cer, # Setting in line with Wackou's price feed scripts mssr=110, mcr=200, account="REPLACE_WITH_YOUR_USERNAME"))
def ticker_test(): start = time.time() bitshares = BitShares(node=TEST_CONFIG['node']) market = Market('OPEN.BTC:BTS', bitshares_instance=bitshares) ticker = market.ticker() print(ticker) end = time.time() print("Total time: {}".format(end - start))
def cancelall(ctx, market, account): """ Cancel all orders of an account in a market """ market = Market(market) ctx.bitshares.bundle = True market.cancel([x["id"] for x in market.accountopenorders(account)], account=account) print_tx(ctx.bitshares.txbuffer.broadcast())
def ticker(ctx, market): """ Show ticker of a market """ market = Market(market, bitshares_instance=ctx.bitshares) ticker = market.ticker() t = [["key", "value"]] for key in ticker: t.append([key, str(ticker[key])]) print_table(t)
def ticker(ctx, market): """ Show ticker of a market """ market = Market(market, bitshares_instance=ctx.bitshares) ticker = market.ticker() t = PrettyTable(["key", "value"]) t.align = 'r' for key in ticker: t.add_row([key, str(ticker[key])]) click.echo(str(t))
def convert_asset(from_value, from_asset, to_asset): """ Converts asset to another based on the latest market value :param from_value: Amount of the input asset :param from_asset: Symbol of the input asset :param to_asset: Symbol of the output asset :return: Asset converted to another asset as float value """ market = Market('{}/{}'.format(from_asset, to_asset)) ticker = market.ticker() latest_price = ticker.get('latest', {}).get('price', None) return from_value * latest_price
def type_intern(self, symbol): """ Process a price from a formula """ asset = Asset(symbol, full=True) short_backing_asset = Asset( asset["bitasset_data"]["options"]["short_backing_asset"]) backing_symbol = short_backing_asset["symbol"] asset["short_backing_asset"] = short_backing_asset if self.assetconf(symbol, "type") != "formula": return if self.assetconf(symbol, "reference") == "extern": price = eval( self.assetconf(symbol, "formula").format(**self.price_result)) elif self.assetconf(symbol, "reference") == "intern": # Parse the forumla according to ref_asset if self.assethasconf(symbol, "ref_asset"): ref_asset = self.assetconf(symbol, "ref_asset") market = Market("%s:%s" % (ref_asset, backing_symbol)) ticker_raw = market.ticker() ticker = {} for k, v in ticker_raw.items(): if isinstance(v, Price): ticker[k] = float(v.as_quote("BTS")) elif isinstance(v, Amount): ticker[k] = float(v) price = eval( str(self.assetconf(symbol, "formula")).format(**ticker)) else: price = eval(str(self.assetconf(symbol, "formula"))) else: raise ValueError("Missing 'reference' for asset %s" % symbol) orientation = self.assetconf(symbol, "formula_orientation", no_fail=True)\ or "{}:{}".format(backing_symbol, symbol) # default value price = Price(price, orientation) cer = self.get_cer(symbol, price) self.price_result[symbol] = { "price": float(price.as_quote(backing_symbol)), "cer": float(cer), "number": 1, "short_backing_symbol": backing_symbol, "mean": float(price), "median": float(price), "weighted": float(price), "mssr": self.assetconf(symbol, "maximum_short_squeeze_ratio"), "mcr": self.assetconf(symbol, "maintenance_collateral_ratio"), "std": 0.0, "number": 1, }
def dummy(): btseth = (Market("BTS:" + str(sys.argv[1])).orderbook( limit=50)['asks'])[1:-1] #ask selling btssmoke = (Market("BTS:" + str(sys.argv[2])).orderbook(limit=50)['bids'] ) #bid buying print(btssmoke) amt = float(sys.argv[3]) eth = str(btseth)[1:int(i1)] smoke = str(btssmoke)[1:int(i2)] print(eth) print(smoke) print(out) sys.stdout.flush()
def get_converted_asset_amount(self, asset): """ Returns asset amount converted to base asset amount """ base_asset = self.market['base'] quote_asset = Asset(asset['symbol'], bitshares_instance=self.bitshares) if base_asset['symbol'] == quote_asset['symbol']: return asset['amount'] else: market = Market(base=base_asset, quote=quote_asset, bitshares_instance=self.bitshares) return market.ticker()['latest']['price'] * asset['amount']
def trades(ctx, market, limit, start, stop): market = Market(market, bitshares_instance=ctx.bitshares) t = PrettyTable(["time", "quote", "base", "price"]) t.align = 'r' for trade in market.trades(limit, start=start, stop=stop): t.add_row([ str(trade["time"]), str(trade["quote"]), str(trade["base"]), "{:f} {}/{}".format(trade["price"], trade["base"]["asset"]["symbol"], trade["quote"]["asset"]["symbol"]), ]) click.echo(str(t))
def convert_asset(from_value, from_asset, to_asset): """ Converts asset to another based on the latest market value :param float | from_value: Amount of the input asset :param string | from_asset: Symbol of the input asset :param string | to_asset: Symbol of the output asset :return: float Asset converted to another asset as float value """ market = Market('{}/{}'.format(from_asset, to_asset)) ticker = market.ticker() latest_price = ticker.get('latest', {}).get('price', None) precision = market['base']['precision'] return truncate((from_value * latest_price), precision)
def orderbook(ctx, market): """ Show the orderbook of a particular market """ market = Market(market, bitshares_instance=ctx.bitshares) orderbook = market.orderbook() ta = {} ta["bids"] = PrettyTable( ["quote", "sum quote", "base", "sum base", "price"]) ta["bids"].align = "r" cumsumquote = Amount(0, market["quote"]) cumsumbase = Amount(0, market["base"]) for order in orderbook["bids"]: cumsumbase += order["base"] cumsumquote += order["quote"] ta["bids"].add_row([ str(order["quote"]), str(cumsumquote), str(order["base"]), str(cumsumbase), "{:f} {}/{}".format(order["price"], order["base"]["asset"]["symbol"], order["quote"]["asset"]["symbol"]), ]) ta["asks"] = PrettyTable([ "price", "base", "sum base", "quote", "sum quote", ]) ta["asks"].align = "r" ta["asks"].align["price"] = "l" cumsumquote = Amount(0, market["quote"]) cumsumbase = Amount(0, market["base"]) for order in orderbook["asks"]: cumsumbase += order["base"] cumsumquote += order["quote"] ta["asks"].add_row([ "{:f} {}/{}".format(order["price"], order["base"]["asset"]["symbol"], order["quote"]["asset"]["symbol"]), str(order["base"]), str(cumsumbase), str(order["quote"]), str(cumsumquote), ]) t = PrettyTable(["bids", "asks"]) t.add_row([str(ta["bids"]), str(ta["asks"])]) click.echo(t)
def market_trade_history(market_pair: hug.types.text, api_key: hug.types.text, hug_timer=5): """Given a valid market_pair (e.g. USD:BTS) & a TX limit, output the market's trade history in JSON.""" if (check_api_token(api_key) == True): # Check the api key # API KEY VALID try: target_market = Market(market_pair) except: # Market is not valid return { 'valid_market': False, 'valid_key': True, 'took': float(hug_timer) } temp_market_history = list(target_market.trades(limit=100)) #print(temp_market_history) # (2017-12-24 15:37:21) 55.8699 USD 106.84792 BTS @ 1.912441583 BTS/USD market_history_json_list = [] for market_trade in temp_market_history: str_market_trade = str(market_trade).split( " @ " ) # ["(2017-12-24 15:37:21) 55.8699 USD 106.84792 BTS", "1.912441583 BTS/USD"] trade_rate = str_market_trade[1] # "1.912441583 BTS/USD" trade_time = (str_market_trade[0].split(") ")[0]).replace("(", "") trade_details = str_market_trade[0].split(") ")[1] split_trade = trade_details.split(" ") market_history_json_list.append({ "datetime": trade_time.replace(" ", "T"), "bought": split_trade[0] + " " + split_trade[1], "sold": split_trade[2] + " " + split_trade[3], "rate ": trade_rate }) return { 'market_trade_history': market_history_json_list, 'market': market_pair, 'valid_market': True, 'valid_key': True, 'took': float(hug_timer) } else: # API KEY INVALID! return {'valid_key': False, 'took': float(hug_timer)}
def trades(ctx, market, limit, start, stop): """ List trades in a market """ market = Market(market, bitshares_instance=ctx.bitshares) t = [["time", "quote", "base", "price"]] for trade in market.trades(limit, start=start, stop=stop): t.append([ str(trade["time"]), str(trade["quote"]), str(trade["base"]), "{:f} {}/{}".format(trade["price"], trade["base"]["asset"]["symbol"], trade["quote"]["asset"]["symbol"]), ]) print_table(t)
def spread(ctx, market, side, min, max, num, total, order_expiration, account): """ Place multiple orders \b :param str market: Market pair quote:base (e.g. USD:BTS) :param str side: ``buy`` or ``sell`` quote :param float min: minimum price to place order at :param float max: maximum price to place order at :param int num: Number of orders to place :param float total: Total amount of quote to use for all orders :param int order_expiration: Number of seconds until the order expires from the books """ from tqdm import tqdm from numpy import linspace market = Market(market) ctx.bitshares.bundle = True if min < max: space = linspace(min, max, num) else: space = linspace(max, min, num) func = getattr(market, side) for p in tqdm(space): func(p, total / float(num), account=account, expiration=order_expiration) print_tx(ctx.bitshares.txbuffer.broadcast())
def _fetch(self): from bitshares.market import Market feed = {} try: for base in self.bases: for quote in self.quotes: if quote == base: continue ticker = Market("%s:%s" % (quote, base)).ticker() if hasattr(self, "quoteNames") and quote in self.quoteNames: quote = self.quoteNames[quote] feed[base] = {} if (float(ticker["latest"])) > 0 and float( ticker["quoteVolume"]) > 0: feed[base][quote] = { "price": (float(ticker["latest"])), "volume": (float(ticker["quoteVolume"]) * self.scaleVolumeBy) } except Exception as e: raise Exception("\nError fetching results from {1}! ({0})".format( str(e), type(self).__name__)) return feed
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
# наш коэф. перекрытия init_ratio = 2.00 max_ratio = 2.10 margin_ratio = 1.75 # наш аккаунт our_account = "id-b0t" our_symbol = "CNY" current_ratio = 0 # наша пара base = Asset(our_symbol) quote = Asset("BTS") # выбираем рынок market = Market(base, quote) # открываем свой локальный кошелек market.bitshares.wallet.unlock("secret_wallet_password") # получаем аккаунт для работы бота account = Account(our_account) print(account) # проверяем есть ли займы по нашему битассету cp = account.callpositions # если есть любые займы if len(cp) > 0: print(cp) # проверяем есть ли по юаню cp2 = cp.get(our_symbol)