public OkexPositionBriefInfo getHoldPosition(OkexFutureInstrumentType instrument, OkexFutureContractType contract,
OkexFutureTradeDirectionType direction, uint leverRate)
{
OkexPositionBriefInfo briefInfo = null;
List <OkexPositionInfo> info;
bool hold = getFuturePosition(instrument, contract, out info);
if (hold)
{
foreach (var pi in info)
{
OkexFutureContractType ct = OkexDefValueConvert.parseContractType(pi.contract_type);
if (ct == contract && leverRate == pi.lever_rate)
{
OkexPositionBriefInfo bi = new OkexPositionBriefInfo(pi, instrument, contract, direction);
if (bi.amount > 0)
{
briefInfo = bi;
break;
}
}
}
}
return(briefInfo);
}
private void transferToTarget(long targetFromPosition, long targetToPosition,
OkexFutureContractType fromContract, OkexFutureContractType toContract)
{
long curFromPosition = getAvailablePositionByContract(m_instrument, fromContract, m_tradeDirection);// - getOrderedPositionByContract(m_spotContract, true);
//long curTargetForwardPosition = getPositionByContract(m_instrument, toContract, m_tradeDirection)
// + getOrderedPositionByContract(m_instrument, toContract, m_tradeDirection, true);
if (curFromPosition > targetFromPosition)
{
long targetVol = curFromPosition - targetFromPosition;
OkexFutureDepthData fromDD = OkexFutureTrader.Instance.getMarketDepthData(m_instrument, fromContract);
OkexFutureDepthData toDD = OkexFutureTrader.Instance.getMarketDepthData(m_instrument, toContract);
if (m_tradeDirection == OkexFutureTradeDirectionType.FTD_Sell)
{
long bidVol = fromDD.bids[0].volume;
long askVol = toDD.asks[0].volume;
long vol = Math.Min(bidVol, askVol);
vol = Math.Min(vol, targetVol);
trade(m_instrument, fromContract, fromDD.bids[0].price, vol, OkexContractTradeType.TT_CloseBuy);
trade(m_instrument, toContract, toDD.asks[0].price, vol, OkexContractTradeType.TT_OpenSell);
}
else
{
long askVol = fromDD.asks[0].volume;
long bidVol = toDD.asks[0].volume;
long vol = Math.Min(askVol, bidVol);
vol = Math.Min(vol, targetVol);
trade(m_instrument, fromContract, fromDD.asks[0].price, vol, OkexContractTradeType.TT_CloseSell);
trade(m_instrument, toContract, toDD.bids[0].price, vol, OkexContractTradeType.TT_OpenBuy);
}
}
}
// extension for position holding query
public long getHoldPositionAmount(OkexFutureInstrumentType instrument, OkexFutureContractType contract,
OkexFutureTradeDirectionType direction)
{
long positionAmount = 0;
List <OkexPositionInfo> info;
bool hold = getFuturePosition(instrument, contract, out info);
if (hold)
{
foreach (var pi in info)
{
OkexFutureContractType ct = OkexDefValueConvert.parseContractType(pi.contract_type);
if (ct == contract)
{
OkexPositionBriefInfo bi = new OkexPositionBriefInfo(pi, instrument, contract, direction);
if (bi.amount > 0)
{
positionAmount += bi.amount;
break;
}
}
}
}
return(positionAmount);
}
// 交易 开仓平仓
public long trade(OkexFutureInstrumentType instrument, OkexFutureContractType contract, double price, long amount, OkexContractTradeType tradeType,
uint leverRate = 10, bool matchPrice = false)
{
string strMatchPrice = "";
if (matchPrice)
{
strMatchPrice = "1";
}
else
{
strMatchPrice = "0";
}
if (leverRate != 10 && leverRate != 20)
{
leverRate = 10;
}
uint nType = (uint)tradeType;
string str = postRequest.future_trade_ex(OkexDefValueConvert.getInstrumentStr(instrument), OkexDefValueConvert.getContractTypeStr(contract), price.ToString(), amount.ToString(), nType.ToString(),
strMatchPrice, leverRate.ToString());
JObject jo = (JObject)JsonConvert.DeserializeObject(str);
bool ret = (bool)jo["result"];
if (!ret)
{
return(0);
}
long orderID = (long)jo["order_id"];
return(orderID);
}
private int genTargetID(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
int inst = (int)instrument;
int cntr = (int)contract;
return(inst * 10000 + cntr);
}
public bool getCurOrdersInfo(OkexFutureInstrumentType instrument, OkexFutureContractType contract,
out List <OkexFutureOrderBriefInfo> briefInfo, bool finished = false)
{
List <OkexFutureOrderBriefInfo> ordersBriefInfo = new List <OkexFutureOrderBriefInfo>();
string strFinished = "1";
if (finished)
{
strFinished = "2";
}
string str = postRequest.future_order_info(OkexDefValueConvert.getInstrumentStr(instrument), OkexDefValueConvert.getContractTypeStr(contract), "-1", strFinished, "0", "1");
briefInfo = new List <OkexFutureOrderBriefInfo>();
JObject jo = (JObject)JsonConvert.DeserializeObject(str);
bool ret = (bool)jo["result"];
if (ret)
{
JArray arr = JArray.Parse(jo["orders"].ToString());
foreach (var item in arr)
{
OkexFutureOrderBriefInfo obi = new OkexFutureOrderBriefInfo();
obi.amount = (long)item["amount"];
obi.contractName = (string)item["contract_name"];
obi.leverRate = (int)item["lever_rate"];
obi.price = (double)item["price"];
obi.tradeType = (OkexContractTradeType)int.Parse((string)item["type"]);
obi.status = (OkexOrderStatusType)int.Parse((string)item["status"]);
obi.orderID = (long)item["order_id"];
briefInfo.Add(obi);
}
}
return(ret);
}
public void tradeAsync(OkexFutureInstrumentType instrument, OkexFutureContractType contract, double price, long amount, OkexContractTradeType tradeType,
HttpAsyncReq.ResponseCallback callback, uint leverRate = 10, bool matchPrice = false)
{
string strMatchPrice = "";
if (matchPrice)
{
strMatchPrice = "1";
}
else
{
strMatchPrice = "0";
}
if (leverRate != 10 && leverRate != 20)
{
leverRate = 10;
}
uint nType = (uint)tradeType;
postRequest.future_async_trade_ex(OkexDefValueConvert.getInstrumentStr(instrument), OkexDefValueConvert.getContractTypeStr(contract),
price.ToString(), amount.ToString(), nType.ToString(),
strMatchPrice, leverRate.ToString(), callback);
}
public OkexPositionBriefInfo(OkexPositionInfo info, OkexFutureInstrumentType inst,
OkexFutureContractType ct, OkexFutureTradeDirectionType dir)
{
contractID = info.contract_id;
instrument = inst;
contractType = ct;
direction = dir;
leverRate = info.lever_rate;
if (dir == OkexFutureTradeDirectionType.FTD_Buy)
{
amount = info.buy_amount;
available = info.buy_available;
avgPrice = info.buy_price_avg;
costPrice = info.buy_price_cost;
bond = info.buy_bond;
flatPrice = info.buy_flatprice;
}
else
{
amount = info.sell_amount;
available = info.sell_available;
avgPrice = info.sell_price_avg;
costPrice = info.sell_price_cost;
bond = info.sell_bond;
flatPrice = info.sell_flatprice;
}
}
public bool getOrderInfoByID(OkexFutureInstrumentType instrument, OkexFutureContractType contract,
long orderID, out OkexFutureOrderBriefInfo info)
{
//List<OkexFutureOrderBriefInfo> ordersBriefInfo = new List<OkexFutureOrderBriefInfo>();
string str = postRequest.future_order_info(OkexDefValueConvert.getInstrumentStr(instrument), OkexDefValueConvert.getContractTypeStr(contract), orderID.ToString(), "1", "0", "1");
JObject jo = (JObject)JsonConvert.DeserializeObject(str);
bool ret = (bool)jo["result"];
info = new OkexFutureOrderBriefInfo();
if (ret)
{
JArray arr = JArray.Parse(jo["orders"].ToString());
foreach (var item in arr)
{
info.amount = (long)item["amount"];
info.contractName = (string)item["contract_name"];
info.leverRate = (int)item["lever_rate"];
info.price = (double)item["price"];
info.tradeType = (OkexContractTradeType)int.Parse((string)item["type"]);
info.status = (OkexOrderStatusType)int.Parse((string)item["status"]);
info.orderID = (long)item["order_id"];
break;
}
}
return(ret);
}
public OkexLocalOrderBriefInfo(long id, OkexFutureInstrumentType fi, OkexFutureContractType fc, uint lr)
{
orderID = id;
instrumentType = fi;
contractType = fc;
leverRate = lr;
}
public bool cancel(OkexFutureInstrumentType instrument, OkexFutureContractType contract, long orderID)
{
string str = postRequest.future_cancel(OkexDefValueConvert.getInstrumentStr(instrument), OkexDefValueConvert.getContractTypeStr(contract), orderID.ToString());
JObject jo = (JObject)JsonConvert.DeserializeObject(str);
bool ret = (bool)jo["result"];
return(ret);
}
// 获取当前可用合约总持仓量
public long getMarketHoldAmount(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
string str = getRequest.future_hold_amount(OkexDefValueConvert.getInstrumentStr(instrument), OkexDefValueConvert.getContractTypeStr(contract));
JArray arr = JArray.Parse(str);
JObject jo = (JObject)JsonConvert.DeserializeObject(arr[0].ToString());
long amount = (long)jo["amount"];
return(amount);
}
public OkexTransferPositionByBasis(OkexFutureInstrumentType inst, OkexFutureContractType sc, OkexFutureContractType fc,
OkexBasisCalcType type, OkexFutureTradeDirectionType tradeDir)
{
m_instrument = inst;
m_basisCalcType = type;
m_spotContract = sc;
m_forwardContract = fc;
m_tradeDirection = tradeDir;
}
public void saveDepthData(OkexFutureInstrumentType instrument, OkexFutureContractType contract, OkexFutureDepthData depthData)
{
if (!m_depthData.ContainsKey(instrument))
{
ConcurrentDictionary <OkexFutureContractType, OkexFutureDepthData> ddMap = new ConcurrentDictionary <OkexFutureContractType, OkexFutureDepthData>();
m_depthData.TryAdd(instrument, ddMap);
}
m_depthData[instrument][contract] = depthData;
}
private void queryDepthData(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
OkexFutureDepthData dd = OkexFutureTrader.Instance.getMarketDepthData(instrument, contract);
if (dd != null)
{
//saveDepthData(instrument, contract, ref dd);
m_depthData[instrument][contract] = dd;
}
}
private void queryMarketData(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
OkexFutureMarketData md = OkexFutureTrader.Instance.getMarketData(instrument, contract);
if (md != null)
{
//saveMarketData(instrument, contract, ref md);
m_marketData[instrument][contract] = md;
}
}
protected double getCurSellPrice(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
OkexFutureMarketData md = MarketDataMgr.Instance.getMarketData(instrument, contract);
if (md != null)
{
return(md.sell);
}
return(0.0);
}
//public void update()
//{
// foreach (var keyVal in m_subscribedContracts)
// {
// OkexFutureInstrumentType inst = keyVal.Key;
// foreach(var contract in keyVal.Value)
// {
// queryMarketData(inst, contract);
// queryDepthData(inst, contract);
// }
// }
//}
//private void queryMarketData(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
//{
// OkexFutureMarketData md = OkexFutureTrader.Instance.getMarketData(instrument, contract);
// if(md != null)
// {
// //saveMarketData(instrument, contract, ref md);
// m_marketData[instrument][contract] = md;
// }
//}
//private void queryDepthData(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
//{
// OkexFutureDepthData dd = OkexFutureTrader.Instance.getMarketDepthData(instrument, contract);
// if (dd != null)
// {
// //saveDepthData(instrument, contract, ref dd);
// m_depthData[instrument][contract] = dd;
// }
//}
public void saveMarketData(OkexFutureInstrumentType instrument, OkexFutureContractType contract, OkexFutureMarketData marketData)
{
if (!m_marketData.ContainsKey(instrument))
{
ConcurrentDictionary <OkexFutureContractType, OkexFutureMarketData> mdMap = new ConcurrentDictionary <OkexFutureContractType, OkexFutureMarketData>();
m_marketData.TryAdd(instrument, mdMap);
}
m_marketData[instrument][contract] = marketData;
}
public void trade(OkexFutureInstrumentType instrument, OkexFutureContractType contract,
double price, long volume, OkexContractTradeType type, uint leverRate = 10,
FutureTradeEntity.TradeEventHandler callback = null, long queryInterval = 1000)
{
FutureTradeEntity entity = new FutureTradeEntity(instrument, contract, queryInterval);
if (callback != null)
{
entity.setTradeEventHandler(callback);
}
OkexFutureTrader.Instance.tradeAsync(instrument, contract, price, volume, type, entity.onAsyncCallback, leverRate);
m_entityList.Add(entity);
}
//private void saveMarketData(OkexFutureInstrumentType instrument, OkexFutureContractType contract, ref OkexFutureMarketData marketData)
//{
// if (!m_marketData.ContainsKey(instrument))
// {
// Dictionary<OkexFutureContractType, OkexFutureMarketData> mdMap = new Dictionary<OkexFutureContractType, OkexFutureMarketData>();
// m_marketData.Add(instrument, mdMap);
// }
// m_marketData[instrument][contract] = marketData;
//}
//private void saveDepthData(OkexFutureInstrumentType instrument, OkexFutureContractType contract, ref OkexFutureDepthData depthData)
//{
// if (!m_marketData.ContainsKey(instrument))
// {
// Dictionary<OkexFutureContractType, OkexFutureMarketData> mdMap = new Dictionary<OkexFutureContractType, OkexFutureMarketData>();
// m_marketData.Add(instrument, mdMap);
// }
// m_depthData[instrument][contract] = depthData;
//}
public OkexFutureDepthData getDepthData(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
if (!m_depthData.ContainsKey(instrument))
{
return(null);
}
if (!m_depthData[instrument].ContainsKey(contract))
{
return(null);
}
return(m_depthData[instrument][contract]);
}
public void unsubscribeInstrument(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
if (!m_subscribedContracts.ContainsKey(instrument))
{
return;
}
if (!m_subscribedContracts[instrument].Contains(contract))
{
return;
}
m_subscribedContracts[instrument].Remove(contract);
}
private List <OkexTradeCommand> m_tradeCmd = new List <OkexTradeCommand>(); // todo: be optimized by pool
public void applyTrade(OkexFutureInstrumentType instrument, OkexFutureContractType contract, double price, double amount, OkexContractTradeType tradeType,
uint leverRate = 10, bool matchPrice = false)
{
OkexTradeCommand cmd = new OkexTradeCommand();
cmd.instrument = instrument;
cmd.contract = contract;
cmd.price = price;
cmd.amount = amount;
cmd.tradeType = tradeType;
cmd.leverRate = leverRate;
cmd.matchPrice = matchPrice;
m_tradeCmd.Add(cmd);
}
public FutureTradeTracer(string id, FutureTradeEntity fte,
OkexFutureInstrumentType inst, OkexFutureContractType cntr,
long queryInterval = 1000)
{
localID = id;
entity = fte;
queryTimer = new Timer(queryInterval);
resultTimer = new Timer(1000);
instrument = inst;
contract = cntr;
queryTimer.Elapsed += new ElapsedEventHandler(queryTrade);
resultTimer.Elapsed += new ElapsedEventHandler(onTimeout);
}
public OkexStrategy generateStrategy(string type, string info)
{
OkexStrategy s = null;
if (type == "TPByBasis")
{
JObject jo = (JObject)JsonConvert.DeserializeObject(info);
string strInst = (string)jo["Instrument"];
OkexFutureInstrumentType fi = strInstrumentMap[strInst];
string strSC = (string)jo["SpotContract"];
OkexFutureContractType sc = strContractMap[strSC];
string strFC = (string)jo["ForwardContract"];
OkexFutureContractType fc = strContractMap[strFC];
string strDir = (string)jo["Direction"];
OkexFutureTradeDirectionType dir = OkexFutureTradeDirectionType.FTD_Sell;
if (strDir.Equals("buy", StringComparison.OrdinalIgnoreCase))
{
dir = OkexFutureTradeDirectionType.FTD_Buy;
}
else if (strDir.Equals("sell", StringComparison.OrdinalIgnoreCase))
{
dir = OkexFutureTradeDirectionType.FTD_Sell;
}
OkexBasisCalcType bc = OkexBasisCalcType.BC_Ratio;
string strType = (string)jo["Type"];
if (strType.Equals("ratio", StringComparison.OrdinalIgnoreCase))
{
bc = OkexBasisCalcType.BC_Ratio;
}
else if (strType.Equals("diff", StringComparison.OrdinalIgnoreCase))
{
bc = OkexBasisCalcType.BC_Diff;
}
s = new OkexTransferPositionByBasis(fi, sc, fc, bc, dir);
//double boardLot = (double)jo["BoardLot"];
double basis = (double)jo["Basis"];
double safe = (double)jo["Safe"];
double limit = (double)jo["Limit"];
uint count = (uint)jo["Count"];
double param = (double)jo["Param"];
((OkexTransferPositionByBasis)s).init(basis, safe, limit, count, param);
}
return(s);
}
public void trade(FutureTradeEntity entity,
OkexFutureInstrumentType instrument, OkexFutureContractType contract,
double price, long volume, OkexContractTradeType type, uint leverRate = 10)
{
if (entity == null)
{
return;
}
long queryInterval = entity.queryInterval;
string guid = Guid.NewGuid().ToString();
FutureTradeTracer tracer = new FutureTradeTracer(guid, entity, instrument, contract, queryInterval);
m_tracers.TryAdd(guid, tracer);
OkexFutureTrader.Instance.tradeAsync(instrument, contract, price, volume, type, tracer.onTradeResult, leverRate);
tracer.start();
}
protected double getCurPrice(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
OkexFutureMarketData md = OkexFutureTrader.Instance.getMarketData(instrument, contract);
if (md != null)
{
//if(m_tradeDirection == OkexFutureTradeDirectionType.TT_Buy)
//{
// return md.sell;
//}
//else
//{
// return md.buy;
//}
return(md.last);
}
return(0.0);
}
public void subscribeInstrument(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
if (!m_subscribedContracts.ContainsKey(instrument))
{
List <OkexFutureContractType> contractsList = new List <OkexFutureContractType>();
m_subscribedContracts.Add(instrument, contractsList);
}
if (m_subscribedContracts[instrument].Contains(contract))
{
return;
}
m_subscribedContracts[instrument].Add(contract);
//int timerID = genTargetID(instrument, contract);
//Timer t = new Timer();
}
public void subscribeInstrument(OkexFutureInstrumentType instrument, OkexFutureContractType contract)
{
if (!m_subscribedContracts.ContainsKey(instrument))
{
List <OkexFutureContractType> contractsList = new List <OkexFutureContractType>();
m_subscribedContracts.TryAdd(instrument, contractsList);
}
if (m_subscribedContracts[instrument].Contains(contract))
{
return;
}
m_subscribedContracts[instrument].Add(contract);
int id = genTargetID(instrument, contract);
MarketDataUpdater mdu = new MarketDataUpdater(instrument, contract);
m_dataUpdaters.TryAdd(id, mdu);
mdu.start();
}
// 仓位信息
public bool getFuturePosition(OkexFutureInstrumentType instrument, OkexFutureContractType contract, out List <OkexPositionInfo> info)
{
string str = postRequest.future_position_4fix(OkexDefValueConvert.getInstrumentStr(instrument), OkexDefValueConvert.getContractTypeStr(contract));
info = new List <OkexPositionInfo>();
JObject jo = (JObject)JsonConvert.DeserializeObject(str);
bool result = (bool)jo["result"];
if (result)
{
JArray arr = JArray.Parse(jo["holding"].ToString());
foreach (var item in arr)
{
OkexPositionInfo pi = JsonConvert.DeserializeObject <OkexPositionInfo>(item.ToString());
info.Add(pi);
}
}
return(result);
}
public List <OkexContractInfo> getContractsByType(OkexFutureInstrumentType fi, OkexFutureContractType fc)
{
List <OkexContractInfo> allContracts = getContracts(fi);
if (allContracts == null)
{
return(null);
}
List <OkexContractInfo> info = new List <OkexContractInfo>();
foreach (var ci in allContracts)
{
OkexFutureContractType contractType = OkexDefValueConvert.parseContractType(ci.contract_type);
if (contractType == fc)
{
info.Add(ci);
}
}
return(info);
}
