def print_permissions(account):
t = PrettyTable(["Permission", "Threshold", "Key/Account"],
hrules=allBorders)
t.align = "r"
for permission in ["owner", "active"]:
auths = []
# account auths:
for authority in account[permission]["account_auths"]:
auths.append("%s (%d)" %
(Account(authority[0])["name"], authority[1]))
# key auths:
for authority in account[permission]["key_auths"]:
auths.append("%s (%d)" % (authority[0], authority[1]))
t.add_row([
permission,
account[permission]["weight_threshold"],
"\n".join(auths),
])
click.echo(t)
def get_call_orders(self, limit=100):
from .price import Price
from .amount import Amount
assert limit <= 100
assert self.is_bitasset
self.ensure_full()
r = list()
bitasset = self["bitasset_data"]
settlement_price = Price(bitasset["current_feed"]["settlement_price"])
ret = self.bitshares.rpc.get_call_orders(self["id"], limit)
for call in ret[:limit]:
call_price = Price(call["call_price"])
collateral_amount = Amount(
{
"amount": call["collateral"],
"asset_id": call["call_price"]["base"]["asset_id"]
},
bitshares_instance=self.bitshares)
debt_amount = Amount(
{
"amount": call["debt"],
"asset_id": call["call_price"]["quote"]["asset_id"],
},
bitshares_instance=self.bitshares)
r.append({
"account":
Account(call["borrower"],
lazy=True,
bitshares_instance=self.bitshares),
"collateral":
collateral_amount,
"debt":
debt_amount,
"call_price":
call_price,
"settlement_price":
settlement_price,
"ratio":
float(collateral_amount) / float(debt_amount) *
float(settlement_price)
})
return r
def workers(ctx, account, top, sort):
""" List all workers (of an account)
"""
def normalize_sort_keys(name):
if name == "votes":
return "total_votes_for"
return name
workers = Workers(account)
t = [["id", "name/url", "daily_pay", "votes", "time", "account"]]
sort = sort
sort = normalize_sort_keys(sort)
if sort in ["total_votes_for"]:
workers_sorted = sorted(workers,
key=lambda x: int(x[sort]),
reverse=True)
elif sort == "id":
workers_sorted = sorted(workers,
key=lambda x: int(x[sort].split(".")[2]),
reverse=True)
else:
workers_sorted = sorted(workers, key=lambda x: x[sort], reverse=True)
if top:
workers_sorted = workers_sorted[:top + 1]
for worker in workers_sorted:
if worker["work_end_date"] < datetime.datetime.utcnow():
continue
votes = Amount({
"amount": worker["total_votes_for"],
"asset_id": "1.3.0"
})
amount = Amount({"amount": worker["daily_pay"], "asset_id": "1.3.0"})
t.append([
worker["id"],
"{name}\n{url}".format(**worker),
str(amount),
str(votes),
"{work_begin_date:%Y-%m-%d}\n-\n{work_end_date:%Y-%m-%d}".format(
**worker),
str(Account(worker["worker_account"])["name"]),
])
print_table(t)
def update_feed_producers(self, producers):
""" Update bitasset feed producers
:param list producers: List of accounts that are allowed to produce
a feed
"""
assert self.is_bitasset, \
"Asset needs to be a bitasset/market pegged asset"
op = operations.Asset_update_feed_producers(
**{
"fee": {
"amount": 0,
"asset_id": "1.3.0"
},
"issuer": self["issuer"],
"asset_to_update": self["id"],
"new_feed_producers": [Account(a)["id"] for a in producers],
"extensions": []
})
return self.blockchain.finalizeOp(op, self["issuer"], "active")
def get_worker_proposals(api_key: hug.types.text, hug_timer=15):
"""Get a list of all worker proposals!"""
if (check_api_token(api_key) == True): # Check the api key
# API KEY VALID
num_workers_request = request_json(
'{"jsonrpc": "2.0", "method": "get_worker_count", "params": [], "id": 1}'
)
if num_workers_request.status_code is not 200:
# We want to catch any failed GET requests!
return {
'request_status_code_error': True,
'valid_key': True,
'took': float(hug_timer)
}
else:
# Request is valid!
num_workers = num_workers_request.json()['result']
worker_list = []
for worker in range(num_workers):
worker_id = "1.14." + str(worker)
current_worker = bitshares_api_node.rpc.get_objects(
[worker_id])[0]
target_account = Account(current_worker['worker_account'])
target_account_data = extract_object(target_account)
current_worker['worker_account_details'] = target_account_data
worker_list.append(current_worker)
return {
'workers': worker_list,
'valid_key': True,
'took': float(hug_timer)
}
else:
# API KEY INVALID!
return {'valid_key': False, 'took': float(hug_timer)}
def get_committee_member(committee_id: hug.types.text, api_key: hug.types.text, request, hug_timer=15):
"""Retrieve information about a single committee member (inc full account details)!"""
if (check_api_token(api_key) == True): # Check the api key
google_analytics(request, 'get_committee_member')
if ("1.5." not in committee_id):
return {'valid_committee_id': False,
'valid_key': True,
'took': float(hug_timer)}
try:
target_committee_member = bitshares_api_node.rpc.get_objects([committee_id])[0]
except:
return {'valid_committee_id': False,
'valid_key': True,
'took': float(hug_timer)}
if target_committee_member is None:
return {'valid_committee_id': False,
'valid_key': True,
'took': float(hug_timer)}
target_account = Account(target_committee_member['committee_member_account'], full=True) # Full info!
target_account_data = extract_object(target_account)
active_committee_members = Blockchain().config()['active_committee_members']
if committee_id in active_committee_members:
target_account_data['status'] = True
else:
target_account_data['status'] = False
target_committee_member['committee_member_details'] = target_account_data
return {'get_committee_member': target_committee_member,
'valid_committee_id': True,
'valid_key': True,
'took': float(hug_timer)}
else:
# API KEY INVALID!
return {'valid_key': False,
'took': float(hug_timer)}
def issue_asset(inst,
issue_to_account,
to_issue_asset,
amount,
memo=None,
account=None,
**kwargs):
""" issue_asset
:param str account: the account to cancel
to (defaults to ``default_account``)
"""
if not account:
if "default_account" in inst.config:
account = inst.config["default_account"]
if not account:
raise ValueError("You need to provide an account")
account = Account(account)
if 'extensions' in kwargs:
extensions = kwargs['extensions']
else:
extensions = Set([])
print(extensions)
asset_to_issue = {"amount": amount, "asset_id": to_issue_asset}
kwargs = {
'fee': {
"amount": 0,
"asset_id": "1.3.0"
},
'issuer': account["id"],
'asset_to_issue': asset_to_issue,
'issue_to_account': issue_to_account,
'memo': memo,
'extensions': extensions
}
op = operations.Asset_issue(**kwargs)
return inst.finalizeOp(op, account, "active")
def importaccount(ctx, account, role):
""" Import an account using an account password
"""
from bitsharesbase.account import PasswordKey
password = click.prompt(
"Account Passphrase",
hide_input=True,
)
account = Account(account, bitshares_instance=ctx.bitshares)
imported = False
if role == "owner":
owner_key = PasswordKey(account["name"], password, role="owner")
owner_pubkey = format(owner_key.get_public_key(), ctx.bitshares.rpc.chain_params["prefix"])
if owner_pubkey in [x[0] for x in account["owner"]["key_auths"]]:
click.echo("Importing owner key!")
owner_privkey = owner_key.get_private_key()
ctx.bitshares.wallet.addPrivateKey(owner_privkey)
imported = True
if role == "active":
active_key = PasswordKey(account["name"], password, role="active")
active_pubkey = format(active_key.get_public_key(), ctx.bitshares.rpc.chain_params["prefix"])
if active_pubkey in [x[0] for x in account["active"]["key_auths"]]:
click.echo("Importing active key!")
active_privkey = active_key.get_private_key()
ctx.bitshares.wallet.addPrivateKey(active_privkey)
imported = True
if role == "memo":
memo_key = PasswordKey(account["name"], password, role=role)
memo_pubkey = format(memo_key.get_public_key(), ctx.bitshares.rpc.chain_params["prefix"])
if memo_pubkey == account["memo_key"]:
click.echo("Importing memo key!")
memo_privkey = memo_key.get_private_key()
ctx.bitshares.wallet.addPrivateKey(memo_privkey)
imported = True
if not imported:
click.echo("No matching key(s) found. Password correct?")
def full_account_info(account_name: hug.types.text,
api_key: hug.types.text,
hug_timer=5):
"""Retrieve verbose information about an individual Bitshares account!"""
try:
target_account = Account(account_name, full=True)
except:
return {
'valid_account': False,
'account': account_name,
'valid_key': True,
'took': float(hug_timer)
}
extracted_object = extract_object(target_account)
return {
'full_account_info': extracted_object,
'valid_key': True,
'took': float(hug_timer)
}
def print_permissions(account):
t = [["Permission", "Threshold", "Key/Account"]]
for permission in ["owner", "active"]:
auths = []
# account auths:
for authority in sorted(account[permission]["account_auths"],
key=lambda x: x[1],
reverse=True):
auths.append("%s (%d)" %
(Account(authority[0])["name"], authority[1]))
# key auths:
for authority in sorted(account[permission]["key_auths"],
key=lambda x: x[1],
reverse=True):
auths.append("%s (%d)" % (authority[0], authority[1]))
t.append([
permission, account[permission]["weight_threshold"],
"\n".join(auths)
])
t.append(["memo", "n/a", account["options"]["memo_key"]])
print_table(t, hrules=True)
def transfer_asset():
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(FROM_ACCOUNT_ACTIVE_PRIVATE_KEY)
except Exception as e:
pass
net.wallet.unlock(WALLET_PASSWD)
acc = Account(FROM_ACCOUNT, bitshares_instance=net)
net.transfer(TO_ACCOUNT,
ASSET_AMOUNT,
ASSET_NAME,
'memo string',
account=acc)
def list_accounts(bitshares_instance):
""" Get all accounts installed in local wallet in format suitable for Whiptail.menu()
Returning format is compatible both with Whiptail and NoWhiptail.
:return: list of tuples (int, 'account_name - key_type')
"""
accounts = []
pubkeys = bitshares_instance.wallet.getPublicKeys(current=True)
for pubkey in pubkeys:
account_ids = bitshares_instance.wallet.getAccountsFromPublicKey(pubkey)
for account_id in account_ids:
account = Account(account_id, bitshares_instance=bitshares_instance)
key_type = bitshares_instance.wallet.getKeyType(account, pubkey)
accounts.append({'name': account.name, 'type': key_type})
account_list = [
(str(num), '{} - {}'.format(account['name'], account['type'])) for num, account in enumerate(accounts)
]
return account_list
def main():
parser = argparse.ArgumentParser(description='Show multiple accounts ids',
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')
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)
if not conf['my_accounts']:
log.critical(
'You need to list your accounts in "my_accounts" config variable')
sys.exit(1)
ids = ''
for account_name in conf['my_accounts']:
account = Account(account_name, bitshares_instance=bitshares)
ids += '"{}" '.format((account['id']))
print(ids)
def get_all_account_balances(api_key: hug.types.text, hug_timer=60):
"""Retrieve all Bitshares account names & balances.
WARNING: This may take hours to complete! """
if (check_api_token(api_key) == True): # Check the api key
# API KEY VALID
chain = Blockchain()
chain_get_all_accounts = chain.get_all_accounts()
list_of_accounts = []
for account in chain_get_all_accounts:
target_account_balances = Account(account).balances
if (len(target_account_balances) > 0):
balance_json_list = []
for balance in target_account_balances:
current_balance_target = Amount(balance)
balance_json_list.append({
current_balance_target.symbol:
current_balance_target.amount
})
list_of_accounts.append({
'account_name': account,
'balances': balance_json_list
})
else:
list_of_accounts.append({
'account_name': account,
'balances': []
})
return {
'accounts': list_of_accounts,
'num_accounts': len(list_of_accounts),
'valid_key': True,
'took': float(hug_timer)
}
else:
# API KEY INVALID!
return {'valid_key': False, 'took': float(hug_timer)}
def openorders(ctx, account):
account = Account(
account or config["default_account"],
bitshares_instance=ctx.bitshares
)
t = PrettyTable([
"Price",
"Quote",
"Base",
"ID"
])
t.align = "r"
for o in account.openorders:
t.add_row([
"{:f} {}/{}".format(
o["price"],
o["base"]["asset"]["symbol"],
o["quote"]["asset"]["symbol"]),
str(o["quote"]),
str(o["base"]),
o["id"]])
click.echo(t)
def account_balances(account_name: hug.types.text, api_key: hug.types.text, request, hug_timer=5):
"""Bitshares account balances! Simply supply an account name & provide the API key!"""
if (check_api_token(api_key) == True): # Check the api key
# API KEY VALID
google_analytics(request, 'account_balances')
try:
target_account = Account(account_name, full=True)
except:
print("Account doesn't exist.")
return {'valid_account': False,
'account': account_name,
'valid_key': True,
'took': float(hug_timer)}
target_account_balances = target_account.balances
if (len(target_account_balances) > 0):
balance_json_list = {}
for balance in target_account_balances:
current_balance_target = Amount(balance)
balance_json_list[current_balance_target.symbol] = current_balance_target.amount
return {'balances': balance_json_list,
'account_has_balances': True,
'account': account_name,
'valid_account': True,
'valid_key': True,
'took': float(hug_timer)}
else:
return {'account_has_balances': False,
'account': account_name,
'valid_account': True,
'valid_key': True,
'took': float(hug_timer)}
else:
# API KEY INVALID!
return {'valid_key': False,
'took': float(hug_timer)}
def account_callpositions(account_name: hug.types.text,
api_key: hug.types.text,
hug_timer=5):
"""Bitshares account call positions! Simply supply an account name & provide the API key!"""
if (check_api_token(api_key) == True): # Check the api key
# API KEY VALID
try:
target_account = Account(account_name)
except:
print("Account doesn't exist.")
return {
'valid_account': False,
'account': account_name,
'valid_key': True,
'took': float(hug_timer)
}
target_account_callpos = target_account.callpositions
if (len(target_account_callpos) > 0):
return {
'call_positions': target_account_callpos,
'account_has_call_positions': True,
'account': account_name,
'valid_account': True,
'valid_key': True,
'took': float(hug_timer)
}
else:
return {
'account_has_call_positions': False,
'account': account_name,
'valid_account': True,
'valid_key': True,
'took': float(hug_timer)
}
else:
# API KEY INVALID!
return {'valid_key': False, 'took': float(hug_timer)}
def cloneaccount(ctx, account_name, account):
""" Clone an account
This copies the owner and active permissions as well as the
options (e.g. votes, memo key)
"""
from bitsharesbase import transactions, operations
account = Account(account)
op = {
"fee": {"amount": 0, "asset_id": "1.3.0"},
"registrar": account["id"],
"referrer": account["id"],
"referrer_percent": 100,
"name": account_name,
'owner': account["owner"],
'active': account["active"],
"options": account["options"],
"extensions": {},
"prefix": ctx.bitshares.rpc.chain_params["prefix"]
}
op = operations.Account_create(**op)
print_tx(ctx.bitshares.finalizeOp(op, account, "active"))
def history(ctx, account, limit, type, csv, exclude, raw):
""" Show history of an account
"""
from bitsharesbase.operations import getOperationNameForId
t = [["#", "time (block)", "operation", "details"]]
for a in account:
account = Account(a, bitshares_instance=ctx.bitshares)
for b in account.history(
limit=limit,
only_ops=type,
exclude_ops=exclude
):
block = BlockHeader(b["block_num"])
row = [
b["id"].split(".")[2],
"%s (%s)" % (block.time(), b["block_num"]),
"{} ({})".format(getOperationNameForId(b["op"][0]), b["op"][0]),
pprintOperation(b) if not raw else json.dumps(b, indent=4),
]
t.append(row)
print_table(t)
def find_witness(witness_name: hug.types.text,
api_key: hug.types.text,
hug_timer=5):
"""Given a valid witness name, output witness data in JSON."""
if (check_api_token(api_key) == True): # Check the api key
# API KEY VALID
try:
target_witness = Witness(witness_name)
except:
# Market is not valid
return {
'valid_witness': False,
'valid_key': True,
'took': float(hug_timer)
}
target_account = Account(target_witness['witness_account'], full=True)
witness_account_data = extract_object(target_account)
witness_role_data = extract_object(target_witness)
active_witnesses = Blockchain().config()['active_witnesses']
if witness_role_data['id'] in active_witnesses:
witness_status = True
else:
witness_status = False
return {
'witness_role_data': witness_role_data,
'witness_account_data': witness_account_data,
'active_witness': witness_status,
'valid_witness': True,
'valid_key': True,
'took': float(hug_timer)
}
else:
# API KEY INVALID!
return {'valid_key': False, 'took': float(hug_timer)}
def account_history(account_name: hug.types.text, api_key: hug.types.text, request, hug_timer=5):
"""Given a valid account name, output the user's history in JSON."""
if (check_api_token(api_key) == True): # Check the api key
# API KEY VALID
google_analytics(request, 'account_history')
try:
target_account = Account(account_name)
except:
# Accoun is not valid!
return {'valid_account': False,
'account': account_name,
'valid_key': True,
'took': float(hug_timer)}
target_account_history = target_account.history(first=0, last=100, limit=100)
tx_container = []
for transaction in target_account_history:
tx_container.append(transaction)
if (len(tx_container) > 0):
return {'tx_history': tx_container,
'account_has_tx_history': True,
'account': account_name,
'valid_account': True,
'valid_key': True,
'took': float(hug_timer)}
else:
return {'account_has_tx_history': False,
'account': account_name,
'valid_account': True,
'valid_key': True,
'took': float(hug_timer)}
else:
# API KEY INVALID!
return {'valid_key': False,
'took': float(hug_timer)}
def history(ctx, account, limit, type, csv, exclude, raw, memo):
""" Show history of an account
"""
from bitsharesbase.operations import getOperationNameForId
if memo:
pwd = click.prompt("Current Wallet Passphrase", hide_input=True)
ctx.bitshares.wallet.unlock(pwd)
t = [["#", "time (block)", "operation", "details"]]
for a in account:
account = Account(a, bitshares_instance=ctx.bitshares)
for b in tqdm(account.history(limit=limit, only_ops=type, exclude_ops=exclude)):
block = BlockHeader(b["block_num"])
row = [
b["id"],
"%s (%s)" % (block.time(), b["block_num"]),
"{} ({})".format(getOperationNameForId(b["op"][0]), b["op"][0]),
pprintOperation(b, memo, ctx) if not raw else json.dumps(b, indent=4),
]
t.append(row)
print_table(t)
def get_worker(worker_id: hug.types.text,
api_key: hug.types.text,
hug_timer=15):
"""Retrieve a specific worker proposal & the details of the worker's account."""
if (check_api_token(api_key) == True): # Check the api key
# API KEY VALID
if '1.14' not in worker_id:
return {
'valid_worker': False,
'valid_key': True,
'took': float(hug_timer)
}
try:
target_worker = bitshares_api_node.rpc.get_objects([worker_id])[0]
except:
return {
'valid_worker': False,
'valid_key': True,
'took': float(hug_timer)
}
target_account = Account(target_worker['worker_account'], full=True)
target_account_data = extract_object(target_account)
target_worker['worker_account_details'] = target_account_data
return {
'worker': target_worker,
'valid_worker': True,
'valid_key': True,
'took': float(hug_timer)
}
else:
# API KEY INVALID!
return {'valid_key': False, 'took': float(hug_timer)}
def addkey(ctx, key):
""" Add a private key to the wallet
"""
if not key:
while True:
key = click.prompt(
"Private Key (wif) [Enter to quit]",
hide_input=True,
show_default=False,
default="exit"
)
if not key or key == "exit":
break
try:
ctx.bitshares.wallet.addPrivateKey(key)
except Exception as e:
click.echo(str(e))
continue
else:
for k in key:
try:
ctx.bitshares.wallet.addPrivateKey(k)
except Exception as e:
click.echo(str(e))
installedKeys = ctx.bitshares.wallet.getPublicKeys()
if len(installedKeys) == 1:
name = ctx.bitshares.wallet.getAccountFromPublicKey(installedKeys[0])
if name: # only if a name to the key was found
account = Account(name, bitshares_instance=ctx.bitshares)
click.echo("=" * 30)
click.echo("Setting new default user: %s" % account["name"])
click.echo()
click.echo("You can change these settings with:")
click.echo(" uptick set default_account <account>")
click.echo("=" * 30)
config["default_account"] = account["name"]
def test_create_asset(self):
symbol = "FOOBAR"
precision = 7
max_supply = 100000
description = "Test asset"
is_bitasset = True
market_fee_percent = 0.1
max_market_fee = 10
blacklist_authorities = ["init1"]
blacklist_authorities_ids = [
Account(a)["id"] for a in blacklist_authorities
]
blacklist_markets = ["BTS"]
blacklist_markets_ids = ["1.3.0"]
permissions = {
"charge_market_fee": True,
"white_list": True,
"override_authority": True,
"transfer_restricted": True,
"disable_force_settle": True,
"global_settle": True,
"disable_confidential": True,
"witness_fed_asset": True,
"committee_fed_asset": True,
}
flags = {
"charge_market_fee": False,
"white_list": False,
"override_authority": False,
"transfer_restricted": False,
"disable_force_settle": False,
"global_settle": False,
"disable_confidential": False,
"witness_fed_asset": False,
"committee_fed_asset": False,
}
tx = bitshares.create_asset(
symbol,
precision,
max_supply,
market_fee_percent=market_fee_percent,
max_market_fee=max_market_fee,
description=description,
is_bitasset=is_bitasset,
blacklist_authorities=blacklist_authorities,
blacklist_markets=blacklist_markets,
permissions=permissions,
flags=flags,
)
self.assertEqual(getOperationNameForId(tx["operations"][0][0]),
"asset_create")
op = tx["operations"][0][1]
self.assertEqual(op["issuer"], "1.2.100")
self.assertEqual(op["symbol"], symbol)
self.assertEqual(op["precision"], precision)
self.assertEqual(op["common_options"]["max_supply"],
int(max_supply * 10**precision))
self.assertEqual(op["common_options"]["market_fee_percent"],
int(market_fee_percent * 100))
self.assertEqual(
op["common_options"]["max_market_fee"],
int(max_market_fee * 10**precision),
)
self.assertEqual(op["common_options"]["description"], description)
self.assertEqual(op["common_options"]["blacklist_authorities"],
blacklist_authorities_ids)
self.assertEqual(op["common_options"]["blacklist_markets"],
blacklist_markets_ids)
self.assertEqual(todict(op["common_options"]["issuer_permissions"]),
permissions)
self.assertEqual(todict(op["common_options"]["flags"]), flags)
def __init__(self,
name,
config=None,
onAccount=None,
onOrderMatched=None,
onOrderPlaced=None,
onMarketUpdate=None,
onUpdateCallOrder=None,
ontick=None,
bitshares_instance=None,
*args,
**kwargs):
# BitShares instance
self.bitshares = bitshares_instance or shared_bitshares_instance()
# Storage
Storage.__init__(self, name)
# Statemachine
StateMachine.__init__(self, name)
# Events
Events.__init__(self)
if ontick:
self.ontick += ontick
if onMarketUpdate:
self.onMarketUpdate += onMarketUpdate
if onAccount:
self.onAccount += onAccount
if onOrderMatched:
self.onOrderMatched += onOrderMatched
if onOrderPlaced:
self.onOrderPlaced += onOrderPlaced
if onUpdateCallOrder:
self.onUpdateCallOrder += onUpdateCallOrder
# Redirect this event to also call order placed and order matched
self.onMarketUpdate += self._callbackPlaceFillOrders
if config:
self.config = config
else:
self.config = config = Config.get_worker_config_file(name)
self.worker = config["workers"][name]
self._account = Account(self.worker["account"],
full=True,
bitshares_instance=self.bitshares)
self._market = Market(config["workers"][name]["market"],
bitshares_instance=self.bitshares)
# Recheck flag - Tell the strategy to check for updated orders
self.recheck_orders = False
# Settings for bitshares instance
self.bitshares.bundle = bool(self.worker.get("bundle", False))
# Disabled flag - this flag can be flipped to True by a worker and
# will be reset to False after reset only
self.disabled = False
# A private logger that adds worker identify data to the LogRecord
self.log = logging.LoggerAdapter(
logging.getLogger('dexbot.per_worker'), {
'worker_name': name,
'account': self.worker['account'],
'market': self.worker['market'],
'is_disabled': lambda: self.disabled
})
self.orders_log = logging.LoggerAdapter(
logging.getLogger('dexbot.orders_log'), {})
def __init__(self,
name,
config=None,
onAccount=None,
onOrderMatched=None,
onOrderPlaced=None,
onMarketUpdate=None,
onUpdateCallOrder=None,
ontick=None,
bitshares_instance=None,
*args,
**kwargs):
# BitShares instance
self.bitshares = bitshares_instance or shared_bitshares_instance()
# Storage
Storage.__init__(self, name)
# Events
Events.__init__(self)
if ontick:
self.ontick += ontick
if onMarketUpdate:
self.onMarketUpdate += onMarketUpdate
if onAccount:
self.onAccount += onAccount
if onOrderMatched:
self.onOrderMatched += onOrderMatched
if onOrderPlaced:
self.onOrderPlaced += onOrderPlaced
if onUpdateCallOrder:
self.onUpdateCallOrder += onUpdateCallOrder
# Redirect this event to also call order placed and order matched
self.onMarketUpdate += self._callbackPlaceFillOrders
self.assets_intersections_data = None
if config:
self.config = config
self.assets_intersections_data = Config.assets_intersections(
config)
else:
self.config = config = Config.get_worker_config_file(name)
# Get worker's parameters from the config
self.worker = config["workers"][name]
# Recheck flag - Tell the strategy to check for updated orders
self.recheck_orders = False
# Count of orders to be fetched from the API
self.fetch_depth = 8
# What percent of balance the worker should use
self.operational_percent_quote = self.worker.get(
'operational_percent_quote', 0) / 100
self.operational_percent_base = self.worker.get(
'operational_percent_base', 0) / 100
# Get Bitshares account and market for this worker
self._account = Account(self.worker["account"],
full=True,
bitshares_instance=self.bitshares)
self._market = Market(config["workers"][name]["market"],
bitshares_instance=self.bitshares)
# Set fee asset
fee_asset_symbol = self.worker.get('fee_asset')
if fee_asset_symbol:
try:
self.fee_asset = Asset(fee_asset_symbol,
bitshares_instance=self.bitshares)
except bitshares.exceptions.AssetDoesNotExistsException:
self.fee_asset = Asset('1.3.0',
bitshares_instance=self.bitshares)
else:
# If there is no fee asset, use BTS
self.fee_asset = Asset('1.3.0', bitshares_instance=self.bitshares)
# CER cache
self.core_exchange_rate = None
# Ticker
self.ticker = self._market.ticker
# Settings for bitshares instance
self.bitshares.bundle = bool(self.worker.get("bundle", False))
# Disabled flag - this flag can be flipped to True by a worker and will be reset to False after reset only
self.disabled = False
# Order expiration time in seconds
self.expiration = 60 * 60 * 24 * 365 * 5
# buy/sell actions will return order id by default
self.returnOrderId = 'head'
# A private logger that adds worker identify data to the LogRecord
self.log = logging.LoggerAdapter(
logging.getLogger('dexbot.per_worker'), {
'worker_name': name,
'account': self.worker['account'],
'market': self.worker['market'],
'is_disabled': lambda: self.disabled
})
self.orders_log = logging.LoggerAdapter(
logging.getLogger('dexbot.orders_log'), {})
def getProducer(self):
""" Get the feed producers account
"""
self.producer = Account(self.config["producer"])
def test_calls(self):
account = Account("init0")
self.assertIsInstance(account.callpositions, dict)
def main():
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),
bitshares_instance=bitshares)
ticker = market.ticker()
latest_price = ticker.get('latest', {}).get('price', None)
precision = market['base']['precision']
return round((from_value * latest_price), precision)
def transform_asset(sum_balances, from_asset, to_asset):
""" In sum_balances dict, convert one asset into another
:param dict | sum_balances: dict with balances
:param str | from_asset: asset to convert from
:param str | to_asset: destination asset
"""
if from_asset in sum_balances:
amount = convert_asset(sum_balances[from_asset], from_asset,
to_asset)
sum_balances[from_asset] = 0
if to_asset in sum_balances:
sum_balances[to_asset] += amount
else:
sum_balances[to_asset] = amount
return sum_balances
parser = argparse.ArgumentParser(
description=
'Summarize all assets on all accounts and show BTC equivalent',
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')
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)
sum_balances = dict()
for acc in conf['my_accounts']:
account = Account(acc, bitshares_instance=bitshares)
# Avail balances
for i in account.balances:
asset = i['symbol']
sum_balances[asset] = sum_balances.setdefault(asset,
0) + i['amount']
# Balance in orders
for order in account.openorders:
asset = order['for_sale']['symbol']
sum_balances[asset] = sum_balances.setdefault(
asset, 0) + order['for_sale']['amount']
# Margin positions
for asset, details in account.callpositions.items():
sum_balances[asset] = sum_balances.setdefault(
asset, 0) - details['debt']['amount']
asset = details['collateral']['asset']['symbol']
sum_balances[asset] = sum_balances.setdefault(
asset, 0) + details['collateral']['amount']
for asset, amount in sum_balances.items():
log.debug('Total: {} {}'.format(asset, amount))
for from_asset, to_asset in conf['transform_assets'].items():
log.debug('Transforming {} to {}'.format(from_asset, to_asset))
sum_balances = transform_asset(sum_balances, from_asset, to_asset)
for asset, amount in sum_balances.items():
if amount > 0 and asset != conf['btc_asset']:
log.info('Using direct conversion {:.8f} {} -> {}'.format(
amount, asset, conf['btc_asset']))
sum_balances = transform_asset(sum_balances, asset,
conf['btc_asset'])
print('Accounts value in {}: {:.8f}'.format(
conf['btc_asset'], sum_balances[conf['btc_asset']]))
