def on_account(self, d):
"""
处理账号资金信息 可以用资金，冻结资金，总资金
:param d:
:return:
"""
accountid = str(d["account"])
account = self.accounts.get(accountid, None)
if not account:
account = AccountData(accountid=accountid,
gateway_name=self.gateway_name)
self.accounts[accountid] = account
# 总金额（xbt）
account.balance = float(d.get("marginBalance",
account.balance)) / 1000000000
# 可用xbt
account.available = float(d.get("availableMargin",
account.available)) / 1000000000
# 冻结 xbt
account.frozen = account.balance - account.available
# 备注名
user_id = self.user_id
# 删除数据
o_money = Money.delete().where(Money.money_user_id == user_id,
Money.money_accountid == accountid)
o_money.execute() # 执行指令
# 插入数据库
o_money = Money().insert(money_user_id=user_id,
money_balance=account.balance,
money_available=account.available,
money_frozen=account.frozen,
money_accountid=accountid)
o_money.execute() # 执行
def on_query_account(self, data: dict, request: Request) -> None:
""""""
if self.check_error(data, "查询账户"):
return
for d in data["data"]["responseBody"]:
account = AccountData(
accountid=self.open_account,
balance=d["currentBalance"] / 100,
pre_balance=d["beginBalance"] / 100,
available=d["canUseBalance"] / 100,
frozen=d["forbidBalance"] / 100,
commission=d["payFee"] / 100,
margin=(d["lxExDepositBanlance"] + d["lxPreDepositBanlance"]) / 100,
date=str(datetime.now().date()),
time=str(datetime.now().time()),
gateway_name=self.gateway_name,
)
try:
account.percent = round(1 - account.available / account.balance,3) * 100 #资金使用率
except ZeroDivisionError:
account.percent = 0
self.gateway.on_account(account)
def query_account(self):
self.write_log('开始查询账户信息')
try:
assets = self.trade_client.get_assets(segment=True)
except ApiException:
self.write_log("查询资金失败")
return
for i in assets:
account = AccountData(
accountid=self.account,
balance=round(i.summary.net_liquidation, 2),
frozen=0.0,
gateway_name=self.gateway_name,
)
# 下面两个账户仅作vntrader 展示使用。
# 环球账户的资产信息可以通过 summary 获取，标准账户需要区分股票和期货Segment， 且没有合并的summary信息。
sec_account = AccountData(
accountid='Security',
balance=round(i.segments.get('S').net_liquidation, 2),
frozen=0.0,
gateway_name=self.gateway_name,
)
com_account = AccountData(
accountid='Commodity',
balance=round(i.segments.get('C').net_liquidation, 2),
frozen=0.0,
gateway_name=self.gateway_name,
)
self.on_account(account)
self.on_account(sec_account)
self.on_account(com_account)
self.write_log('账户信息查询完成')
def on_query_account(self, data: dict, request: Request) -> None:
""""""
if self.check_error(data, "查询账户"):
return
if self.usdt_base:
for d in data["data"]:
if d["margin_mode"] == "cross":
account = AccountData(
accountid=d["margin_account"],
balance=d["margin_balance"],
frozen=d["margin_frozen"],
gateway_name=self.gateway_name,
)
self.gateway.on_account(account)
else:
for d in data["data"]:
account = AccountData(
accountid=d["symbol"],
balance=d["margin_balance"],
frozen=d["margin_frozen"],
gateway_name=self.gateway_name,
)
self.gateway.on_account(account)
def onRspQryTradingAccount(self, data: dict, error: dict, reqid: int,
last: bool):
""""""
if "AccountID" not in data:
return
account = AccountData(
accountid=data["AccountID"],
balance=round(data["Balance"], 3),
pre_balance=round(data['PreBalance'], 3), #上个交易日总资金
available=round(data["Available"], 3), #可用资金
commission=round(data['Commission'], 3), #手续费
margin=round(data['CurrMargin'], 3), #账户保证金
close_profit=round(data['CloseProfit'], 3), #平仓盈亏
position_profit=round(data['PositionProfit'], 3), #持仓盈亏
frozen=round(
data["FrozenMargin"] + data["FrozenCash"] +
data["FrozenCommission"], 3), #冻结资金
date=str(datetime.now().date()),
time=str(datetime.now().time()),
gateway_name=self.gateway_name,
)
try:
account.percent = round(account.margin / account.balance,
3) * 100 #资金使用率
except ZeroDivisionError:
account.percent = 0
self.gateway.on_account(account)
def onRspQryTradingAccount(self, data: dict, error: dict, reqid: int, last: bool):
""""""
account = AccountData(
accountid=data["AccountID"],
balance=data["Balance"],
frozen=data["FrozenMargin"] + data["FrozenCash"] + data["FrozenCommission"],
gateway_name=self.gateway_name
)
account.available = data["Available"]
self.gateway.on_account(account)
def onRspQryTradingAccount(self, data: dict, error: dict, reqid: int,
last: bool):
""""""
account = AccountData(accountid=data["AccountID"],
balance=data["Balance"],
frozen=data["FrozenMargin"] +
data["FrozenCash"] + data["FrozenCommission"],
gateway_name=self.gateway_name)
account.available = data["Available"]
self.gateway.on_account(account)
def on_account(self, d):
""""""
accountid = str(d["account"])
account = self.accounts.get(accountid, None)
if not account:
account = AccountData(accountid=accountid,
gateway_name=self.gateway_name)
self.accounts[accountid] = account
account.balance = d.get("marginBalance", account.balance)
account.available = d.get("availableMargin", account.available)
account.frozen = account.balance - account.available
self.gateway.on_account(copy(account))
def on_account(self, d):
""""""
accountid = str(d["account"])
account = self.accounts.get(accountid, None)
if not account:
account = AccountData(accountid=accountid,
gateway_name=self.gateway_name)
self.accounts[accountid] = account
account.balance = d.get("marginBalance", account.balance)
account.available = d.get("availableMargin", account.available)
account.frozen = account.balance - account.available
self.gateway.on_account(copy(account))
def on_wallet(self, data):
""""""
if str(data[0]) == "exchange":
accountid = str(data[1])
account = self.accounts.get(accountid, None)
if not account:
account = AccountData(
accountid=accountid,
gateway_name=self.gateway_name,
)
account.balance = float(data[2])
account.available = 0.0
account.frozen = 0.0
self.gateway.on_account(copy(account))
def on_query_position(self, data: dict, request: Request):
""""""
if self.check_error("查询持仓", data):
return
for d in data["result"]:
if d["side"] == "Buy":
volume = d["size"]
else:
volume = -d["size"]
position = PositionData(symbol=d["symbol"],
exchange=Exchange.BYBIT,
direction=Direction.NET,
volume=volume,
price=d["entry_price"],
gateway_name=self.gateway_name)
self.gateway.on_position(position)
account = AccountData(
accountid=d["symbol"].replace("USD", ""),
balance=d["wallet_balance"],
frozen=d["order_margin"],
gateway_name=self.gateway_name,
)
self.gateway.on_account(account)
def on_account(self, data: dict) -> None:
""""""
account = AccountData(accountid=data["underlying"],
balance=float(data["equity"]),
frozen=float(data.get("margin_for_unfilled", 0)),
gateway_name=self.gateway_name)
self.gateway.on_account(account)
def on_account(self, packet: dict) -> None:
""""""
for acc_data in packet["a"]["B"]:
account = AccountData(accountid=acc_data["a"],
balance=float(acc_data["wb"]),
frozen=float(acc_data["wb"]) -
float(acc_data["cw"]),
gateway_name=self.gateway_name)
if account.balance:
self.gateway.on_account(account)
for pos_data in packet["a"]["P"]:
if pos_data["ps"] == "BOTH":
volume = pos_data["pa"]
if '.' in volume:
volume = float(volume)
else:
volume = int(volume)
position = PositionData(
symbol=pos_data["s"],
exchange=Exchange.BINANCE,
direction=Direction.NET,
volume=volume,
price=float(pos_data["ep"]),
pnl=float(pos_data["cr"]),
gateway_name=self.gateway_name,
)
self.gateway.on_position(position)
def on_query_account_balance(self, data, request):
"""
查询账户资金
:param data:
:param request:
:return:
"""
if self.check_error(data, "查询账户资金"):
return
buf = {}
for d in data["data"]["list"]:
currency = d["currency"]
currency_data = buf.setdefault(currency, {})
currency_data[d["type"]] = float(d["balance"])
for currency, currency_data in buf.items():
account = AccountData(
accountid=currency,
balance=currency_data["trade"] + currency_data["frozen"],
frozen=currency_data["frozen"],
gateway_name=self.gateway_name,
)
if account.balance:
self.gateway.on_account(account)
def on_query_account(self, data, request):
""""""
for acc in data:
account_id = str(acc["currency"])
account = self.accounts.get(account_id, None)
if not account:
account = AccountData(accountid=account_id,
gateway_name=self.gateway_name)
self.accounts[account_id] = account
account.balance = float(acc.get("balance", account.balance))
account.available = float(acc.get("available", account.available))
account.frozen = float(acc.get("hold", account.frozen))
self.gateway.on_account(copy(account))
def on_account(self, packet: dict) -> None:
"""
websocket返回得Balance/Position信息更新
"""
if not self.accountid:
self.accountid = f"{self.gateway_name}_USDT"
for acc_data in packet["a"]["B"]:
account = AccountData(accountid=acc_data["a"],
balance=float(acc_data["wb"]),
frozen=float(acc_data["wb"]) -
float(acc_data["cw"]),
gateway_name=self.gateway_name)
if account.balance:
self.gateway.on_account(account)
for pos_data in packet["a"]["P"]:
position = PositionData(
symbol=pos_data["s"],
exchange=Exchange.BINANCE,
direction=Direction.NET,
volume=int(float(pos_data["pa"])),
price=float(pos_data["ep"]),
pnl=float(pos_data["cr"]),
gateway_name=self.gateway_name,
)
self.gateway.on_position(position)
def onQueryAsset(self, data: dict, error: dict, request: int, last: bool,
session: int) -> None:
""""""
account = AccountData(accountid=self.userid,
balance=round(data["total_asset"], 2),
frozen=round(data["withholding_amount"], 2),
gateway_name=self.gateway_name)
account.available = round(data["buying_power"], 2)
if data["account_type"] == 1:
self.margin_trading = True
elif data["account_type"] == 2:
account.frozen = round(account.balance - account.available, 2)
self.option_trading = True
self.gateway.on_account(account)
def on_account(self, data: dict) -> None:
""""""
if not data:
return
currency = data["currency"]
change_type = data["changeType"]
if not change_type:
balance = float(data["balance"])
frozen = balance - float(data["available"])
currency_balance[currency] = balance
elif "place" in change_type:
if "available" not in data:
return
balance = currency_balance[currency]
frozen = balance - float(data["available"])
else:
frozen = 0.0
if "balance" in data:
balance = float(data["balance"])
else:
balance = float(data["available"])
currency_balance[currency] = balance
account = AccountData(
accountid=currency,
balance=balance,
frozen=frozen,
gateway_name=self.gateway_name,
)
self.gateway.on_account(account)
def on_account_event(self, data: dict) -> None:
""""""
account = AccountData(accountid=self.token,
balance=data["assets"],
frozen=data["assets"] - data["available"],
gateway_name=self.gateway_name)
self.gateway.on_account(account)
def onQueryCashRsp(self, data: dict, error: dict, reqid: int) -> None:
""""""
account = AccountData(
accountid=data["account_id"],
balance=data["total_amount"] / 10000,
frozen=(data["total_amount"] - data["avail_amount"]) / 10000,
gateway_name=self.gateway_name)
self.gateway.on_account(account)
def on_account(self, d):
""""""
account = AccountData(accountid=d["currency"],
balance=float(d["balance"]),
frozen=float(d["hold"]),
gateway_name=self.gateway_name)
self.gateway.on_account(copy(account))
def on_account_info(self, packet: dict) -> None:
""""""
data = packet["data"]
account = AccountData(
accountid=data["name"], # 用户名
balance=data["balance"], # 账户结余
position_profit=data["profit"], # 账户当前利润
commission=data["commission_blocked"], # 账户当前锁定手续费金额
frozen=data["margin"], # 冻结保证金
available=data["free_margin"], # 可用保证金
percent=data["margin_level"], # 保证金使用率
date=str(datetime.now().date()),
time=str(datetime.now().time()),
gateway_name=self.gateway_name)
account.equity = data["equity"] # 账户权益
self.on_account(account)
def on_account(self, data):
""""""
account = AccountData(
accountid=data["id"],
balance=float(data["equity"]),
gateway_name=self.gateway_name
)
self.gateway.on_account(account)
def OnQueryAsset(self, asset: XTPQueryAssetRsp,
error_info: XTPRspInfoStruct, request_id: int,
is_last: bool, session_id: int) -> Any:
""""""
account = AccountData(accountid=self.userid,
balance=asset.buying_power,
frozen=asset.withholding_amount,
gateway_name=self.gateway_name)
self.gateway.on_account(account)
def on_account_info(self, packet: dict) -> None:
""""""
data = packet["data"]
account = AccountData(accountid=data["name"],
balance=data["balance"],
frozen=data["margin"],
gateway_name=self.gateway_name)
self.on_account(account)
def onRspQryInvestorAccount(self, data: dict, error: dict, reqid: int, last: bool):
""""""
account = AccountData(
accountid=data["AccountID"],
frozen=data["LongMargin"] + data["ShortMargin"],
balance=data["PreBalance"],
gateway_name=self.gateway_name,
)
self.gateway.on_account(account)
def on_account(self, packet):
""""""
for d in packet["B"]:
account = AccountData(accountid=d["a"],
balance=float(d["f"]) + float(d["l"]),
frozen=float(d["l"]),
gateway_name=self.gateway_name)
if account.balance:
self.gateway.on_account(account)
def on_account(self, data: dict) -> None:
""""""
account = AccountData(
accountid=data["accountCode"],
balance=float(data["cash"]),
frozen=float(data["frozenCash"]),
gateway_name=self.gateway_name,
)
self.gateway.on_account(account)
def on_account(self, packet: dict) -> None:
""""""
for d in packet["data"]:
account = AccountData(
accountid="USDT",
balance=d["wallet_balance"],
frozen=d["wallet_balance"] - d["available_balance"],
gateway_name=self.gateway_name,
)
self.gateway.on_account(account)
def on_query_account(self, data, request):
""""""
for account_data in data:
account = AccountData(accountid=account_data["currency"],
balance=float(account_data["balance"]),
frozen=float(account_data["hold"]),
gateway_name=self.gateway_name)
self.gateway.on_account(account)
self.gateway.write_log("OKEX 账户资金查询成功")
def on_account(self, d):
""""""
for key in d:
account_data = d[key]
account = AccountData(accountid=key,
balance=float(account_data["equity"]),
frozen=float(d.get("margin_for_unfilled",
0)),
gateway_name=self.gateway_name)
self.gateway.on_account(account)
def _parse_account_info(info, gateway_name):
"""
parse single 'info' record inside account reply to AccountData.
"""
account = AccountData(
accountid=info['instrument_id'].upper(),
balance=float(info["equity"]),
frozen=float(info["margin_frozen"]),
gateway_name=gateway_name,
)
return account
