exchange.GetPositions

exchange.GetPositions()函数用于获取持仓信息；GetPositions()函数是交易所对象exchange的成员函数。

GetPositions()函数用于获取交易所对象exchange所绑定的交易所账户的持仓信息。exchange对象的成员函数（方法）的用途仅与exchange相关，本文档之后不再赘述。

    
    
    
exchange.GetPositions()

    
    
    
exchange.GetPositions(symbol)

示例

使用期货交易所对象，对多个不同交易对、不同合约代码的品种下市价单，并通过多种方式查询持仓信息。

    javascript
    
    
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

function main() {
    var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]

    for (var symbol of arrSymbol) {
        exchange.CreateOrder(symbol, "buy", -1, 1)
        exchange.CreateOrder(symbol, "sell", -1, 1)
    }

    var defaultPositions = exchange.GetPositions()
    var swapPositions = exchange.GetPositions("USDT.swap")
    var futuresPositions = exchange.GetPositions("USDT.futures")
    var btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")

    var tbls = []
    var arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
    var tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
    for (var index in arr) {
        var positions = arr[index]
        var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], rows: [] }
        for (var pos of positions) {
            tbl.rows.push([pos.Symbol, pos.MarginLevel, pos.Amount, pos.FrozenAmount, pos.Price, pos.Profit, pos.Type, pos.ContractType, pos.Margin])
        }
        tbls.push(tbl)
    }

    LogStatus("`" + JSON.stringify(tbls) + "`")

    // 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
    return
}

    python
    
    
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''

import json

def main():
    arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]

    for symbol in arrSymbol:
        exchange.CreateOrder(symbol, "buy", -1, 1)
        exchange.CreateOrder(symbol, "sell", -1, 1)

    defaultPositions = exchange.GetPositions()
    swapPositions = exchange.GetPositions("USDT.swap")
    futuresPositions = exchange.GetPositions("USDT.futures")
    btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")

    tbls = []
    arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
    tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
    for index in range(len(arr)):
        positions = arr[index]
        tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], "rows": []}
        for pos in positions:
            tbl["rows"].append([pos["Symbol"], pos["MarginLevel"], pos["Amount"], pos["FrozenAmount"], pos["Price"], pos["Profit"], pos["Type"], pos["ContractType"], pos["Margin"]])

        tbls.append(tbl)

    LogStatus("`" + json.dumps(tbls) + "`")

    return

    rust
    
    
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

fn main() {
    let arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"];

    for symbol in arrSymbol {
        exchange.CreateOrder(symbol, "buy", -1, 1);
        exchange.CreateOrder(symbol, "sell", -1, 1);
    }

    let defaultPositions = exchange.GetPositions(None).unwrap();
    let swapPositions = exchange.GetPositions("USDT.swap").unwrap();
    let futuresPositions = exchange.GetPositions("USDT.futures").unwrap();
    let btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap").unwrap();

    // Rust SDK 没有JSON序列化，使用format!拼接表格的JSON文本
    let mut tbls: Vec<String> = Vec::new();
    let arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions];
    let tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"];
    for (index, positions) in arr.iter().enumerate() {
        let mut rows: Vec<String> = Vec::new();
        for pos in positions {
            rows.push(format!(r#"["{}", {}, {}, {}, {}, {}, {}, "{}", {}]"#, pos.Symbol, pos.MarginLevel, pos.Amount, pos.FrozenAmount, pos.Price, pos.Profit, pos.Type, pos.ContractType, pos.Margin));
        }
        let tbl = format!(r#"{{"type": "table", "title": "{}", "cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], "rows": [{}]}}"#, tblDesc[index], rows.join(","));
        tbls.push(tbl);
    }

    LogStatus!(format!("`[{}]`", tbls.join(",")));

    // 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
    return;
}

    c++
    
    
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

void main() {
    auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};

    for (const auto& symbol : arrSymbol) {
        exchange.CreateOrder(symbol, "buy", -1, 1);
        exchange.CreateOrder(symbol, "sell", -1, 1);
    }

    auto defaultPositions = exchange.GetPositions();
    auto swapPositions = exchange.GetPositions("USDT.swap");
    auto futuresPositions = exchange.GetPositions("USDT.futures");
    auto btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap");

    json tbls = R"([])"_json;
    std::vector<std::vector<Position>> arr = {defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions};
    std::string tblDesc[] = {"defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"};
    for (int index = 0; index < arr.size(); index++) {
        auto positions = arr[index];
        json tbl = R"({
            "type": "table",
            "cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"],
            "rows": []
        })"_json;
        tbl["title"] = tblDesc[index];

        for (const auto& pos : positions) {
            json arrJson = R"([])"_json;

            arrJson.push_back(pos.Symbol);
            arrJson.push_back(pos.MarginLevel);
            arrJson.push_back(pos.Amount);
            arrJson.push_back(pos.FrozenAmount);
            arrJson.push_back(pos.Price);
            arrJson.push_back(pos.Profit);
            arrJson.push_back(pos.Type);
            arrJson.push_back(pos.ContractType);
            arrJson.push_back(pos.Margin);

            tbl["rows"].push_back(arrJson);
        }

        tbls.push_back(tbl);
    }

    LogStatus(_D(), "\n", "`" + tbls.dump() + "`");

    return;
}

返回值

参数

参考

备注

加密货币期货合约与加密货币现货不同，现货仅有逻辑上的持仓概念。在FMZ量化交易平台的系统中，加密货币期货合约的具体品种由**交易对**、**合约代码**共同标识。可参阅exchange.SetCurrency、exchange.SetContractType函数。

在GetPositions函数中，symbol参数的使用场景归纳如下：

在GetPositions函数中，期货交易所对象的查询维度范围归纳如下：

兼容exchange.GetPosition()调用，GetPosition与GetPositions的用法完全一致。

当交易所对象exchange所代表的账户在查询范围内或指定的交易品种上没有持仓时，exchange.GetPositions()函数返回空数组，例如：[]。

exchange.SetMarginLevel

exchange.SetMarginLevel()函数用于设置symbol参数所指定的交易对、合约的杠杆值。同时兼容仅传入marginLevel参数的调用方式，用于设置exchange交易所对象当前交易对、合约的杠杆值。

    
    
    
exchange.SetMarginLevel(symbol, marginLevel)

    
    
    
exchange.SetMarginLevel(marginLevel)

示例

    javascript
    
    
function main() {
    exchange.SetMarginLevel(10)
    // 设置BTC的USDT本位永续合约的杠杆为15
    exchange.SetMarginLevel("BTC_USDT.swap", 15)
}

    python
    
    
def main():
    exchange.SetMarginLevel(10)
    exchange.SetMarginLevel("BTC_USDT.swap", 15)

    rust
    
    
fn main() {
    exchange.SetMarginLevel(10);
    // Rust SDK 中SetMarginLevel函数不支持symbol参数，仅设置当前交易对、合约的杠杆值
    // 如需设置BTC_USDT.swap品种的杠杆为15，需先切换到该交易对、合约后再调用exchange.SetMarginLevel(15)
}

    c++
    
    
void main() {
    exchange.SetMarginLevel(10);
    exchange.SetMarginLevel("BTC_USDT.swap", 15);
}

参数

参考

备注

exchange.SetMarginLevel()函数仅支持加密货币期货合约交易所对象。回测系统支持调用exchange.SetMarginLevel()函数来设置杠杆值。

对于加密货币期货合约而言，由于各加密货币期货合约交易所的杠杆机制并不统一。

在某些交易所中，期货合约的杠杆值是下单接口中的一个参数，此时调用exchange.SetMarginLevel()函数并不会产生网络请求，仅设置FMZ系统底层中的杠杆变量（用于下单接口传参）。

在另一些交易所中，期货合约的杠杆值是交易所的一项独立设置，需要通过交易所网站页面或API接口进行设置。此时调用exchange.SetMarginLevel()函数则会产生网络请求，并且有可能设置失败。失败原因可能有多种，例如：当前存在持仓或挂单，导致该交易对、合约无法再设置新的杠杆值。

不支持exchange.SetMarginLevel()函数的交易所：

exchange.SetDirection

exchange.SetDirection()函数用于设置调用exchange.Buy函数、exchange.Sell函数进行期货合约下单时的订单方向。

    
    
    
exchange.SetDirection(direction)

示例

    javascript
    
    
function main(){
    // 举例设置为OKX期货当周合约
    exchange.SetContractType("this_week")
    // 设置杠杆为5倍
    exchange.SetMarginLevel(5)
    // 设置下单方向为做多
    exchange.SetDirection("buy")
    // 以10000的价格、2张合约数量下单
    exchange.Buy(10000, 2)
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)
}

    python
    
    
def main():
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(5)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)

    rust
    
    
fn main() {
    // 注意：Rust SDK 中不推荐使用SetDirection、Buy、Sell函数，建议优先使用CreateOrder函数，
    // CreateOrder可直接指定side参数（"buy"、"sell"、"closebuy"、"closesell"），无需先调用SetDirection
    // 举例设置为OKX期货当周合约
    exchange.SetContractType("this_week").unwrap();
    // 设置杠杆为5倍
    exchange.SetMarginLevel(5);
    // 设置下单方向为做多
    exchange.SetDirection("buy").unwrap();
    // 以10000的价格、2张合约数量下单
    exchange.Buy(10000, 2).unwrap();
    exchange.SetMarginLevel(5);
    exchange.SetDirection("closebuy").unwrap();
    exchange.Sell(1000, 2).unwrap();
}

    c++
    
    
void main() {
    exchange.SetContractType("this_week");
    exchange.SetMarginLevel(5);
    exchange.SetDirection("buy");
    exchange.Buy(10000, 2);
    exchange.SetMarginLevel(5);
    exchange.SetDirection("closebuy");
    exchange.Sell(1000, 2);
}

参数

参考

备注

exchange.SetDirection()函数用于设置期货合约交易方向与下单函数之间的对应关系：

exchange.SetContractType

exchange.SetContractType()函数用于设置exchange交易所对象当前的合约代码。

    
    
    
exchange.SetContractType(symbol)

示例

• 将当前合约设置为当周合约：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 设置为当周合约
      exchange.SetContractType("this_week")
  }
  

  
      python
      
      
  def main():
      exchange.SetContractType("this_week")
  

  
      rust
      
      
  fn main() {
      // 设置为当周合约
      exchange.SetContractType("this_week").unwrap();
  }
  

  
      c++
      
      
  void main() {
      exchange.SetContractType("this_week");
  }
  

• 在设置以USDT作为保证金的合约时，需要在代码中切换交易对（也可以在添加交易所对象时直接设置交易对）：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 默认交易对为BTC_USD，设置合约为当周，合约为币本位合约
      exchange.SetContractType("this_week")
      Log("ticker:", exchange.GetTicker())
  
      // 切换交易对，然后设置合约，切换成USDT作为保证金的合约，区别于币本位合约
      exchange.IO("currency", "BTC_USDT")
      exchange.SetContractType("swap")
      Log("ticker:", exchange.GetTicker())
  }
  

  
      python
      
      
  def main():
      exchange.SetContractType("this_week")
      Log("ticker:", exchange.GetTicker())
      exchange.IO("currency", "BTC_USDT")
      exchange.SetContractType("swap")
      Log("ticker:", exchange.GetTicker())
  

  
      rust
      
      
  fn main() {
      // 默认交易对为BTC_USD，设置合约为当周，合约为币本位合约
      exchange.SetContractType("this_week").unwrap();
      Log!("ticker:", exchange.GetTicker(None));
  
      // 切换交易对，然后设置合约，切换成USDT作为保证金的合约，区别于币本位合约
      exchange.IO(("currency", "BTC_USDT")).unwrap();
      exchange.SetContractType("swap").unwrap();
      Log!("ticker:", exchange.GetTicker(None));
  }
  

  
      c++
      
      
  void main() {
      exchange.SetContractType("this_week");
      Log("ticker:", exchange.GetTicker());
      exchange.IO("currency", "BTC_USDT");
      exchange.SetContractType("swap");
      Log("ticker:", exchange.GetTicker());
  }
  

• 打印exchange.SetContractType()函数的返回值：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      // 设置合约为当周
      var ret = exchange.SetContractType("this_week")
      // 返回当周合约的信息
      Log(ret)
  }
  

  
      python
      
      
  def main():
      ret = exchange.SetContractType("this_week")
      Log(ret)
  

  
      rust
      
      
  fn main() {
      // 设置合约为当周
      let ret = exchange.SetContractType("this_week").unwrap();
      // 返回当周合约的信息
      Log!(ret);
  }
  

  
      c++
      
      
  void main() {
      auto ret = exchange.SetContractType("this_week");
      Log(ret);
  }
  

返回值

参数

参考

备注

在加密货币期货合约策略中，以切换至BTC_USDT交易对为例：

当使用exchange.SetCurrency("BTC_USDT")或exchange.IO("currency", "BTC_USDT")函数切换交易对后，需要再次调用exchange.SetContractType()函数重新设置合约，才能在新的交易对下确定当前需要操作的合约。系统会根据交易对来判定该合约为币本位合约还是USDT本位合约。

例如：当交易对设置为BTC_USDT时，使用exchange.SetContractType("swap")函数将合约代码设置为swap，此时即设置为BTC的USDT本位永续合约。若交易对为BTC_USD，使用exchange.SetContractType("swap")函数将合约代码设置为swap，此时则设置为BTC的币本位永续合约。

详细介绍平台支持的加密货币期货合约交易所，各交易所的合约命名方式如下：

• Futures_OKCoin（OKX）
  设置为永续合约：exchange.SetContractType("swap")
  设置为当周合约：exchange.SetContractType("this_week")
  设置为次周合约：exchange.SetContractType("next_week")
  设置为月度合约：exchange.SetContractType("month")
  设置为次月合约：exchange.SetContractType("next_month")
  设置为季度合约：exchange.SetContractType("quarter")
  设置为次季合约：exchange.SetContractType("next_quarter")

  OKX提供盘前交易合约，此类合约的交割日期为固定时间。以交易所定义的合约代码HMSTR-USDT-250207为例，先在发明者平台将交易对设置为HMSTR_USDT，然后使用exchange.SetContractType("HMSTR-USDT-250207")设置该合约。
  对于支持symbol参数的函数（例如exchange.GetTicker()、exchange.CreateOrder()等），可以将symbol参数指定为HMSTR_USDT.HMSTR-USDT-250207，以获取该合约的行情数据或进行下单等操作。

• Futures_HuobiDM（火币期货）
  设置为当周合约：exchange.SetContractType("this_week")。
  设置为次周合约：exchange.SetContractType("next_week")。
  设置为季度合约：exchange.SetContractType("quarter")。
  设置为次季合约：exchange.SetContractType("next_quarter")。
  设置为永续合约：exchange.SetContractType("swap")。
  支持以USDT作为保证金的合约。以BTC合约为例：调用exchange.IO("currency", "BTC_USDT")即可切换为以USDT作为保证金的合约，
  或在配置实盘参数、添加交易所对象时直接将当前交易对设置为BTC_USDT。切换交易对后需重新调用exchange.SetContractType()函数设置合约。

• Futures_BitMEX（BitMEX）
  设置为永续合约：exchange.SetContractType("swap")。
  Futures_BitMEX交易所的交割合约为月度合约，合约代码如下（一月至十二月）：

  
              code
              
              
  "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
  

  设置交割合约：exchange.SetContractType("December")。例如，将交易对设置为XBT_USDT时，调用exchange.SetContractType("December")函数即可设置BTC的USDT本位十二月交割合约（对应的实际合约代码为XBTUSDTZ23）。

  Futures_BitMEX合约信息汇总

  Futures_BitMEX定义的合约代码	在FMZ对应的交易对	在FMZ对应的合约代码	备注
  DOGEUSD	DOGE_USD	swap	美元计价，XBT结算。XBT即BTC。
  DOGEUSDT	DOGE_USDT	swap	USDT计价，USDT结算。
  XBTETH	XBT_ETH	swap	ETH计价，XBT结算。
  XBTEUR	XBT_EUR	swap	欧元计价（EUR），XBT结算。
  USDTUSDC	USDT_USDC	swap	USDC计价，XBT结算。
  ETHUSD_ETH	ETH_USD_ETH	swap	美元计价，ETH结算。
  XBTH24	XBT_USD	March	到期日：24年3月，月份代码为H；美元计价，XBT结算。
  ETHUSDZ23	ETH_USD	December	到期日：23年12月，月份代码为Z；美元计价，XBT结算。
  XBTUSDTZ23	XBT_USDT	December	到期日：23年12月，月份代码为Z；USDT计价，USDT结算。
  ADAZ23	ADA_XBT	December	到期日：23年12月，月份代码为Z；XBT计价，XBT结算。
  P_XBTETFX23	USDT_XXX	P_XBTETFX23	到期日：23年11月；以百分比计价，USDT结算。

• Futures_GateIO
  设置为当周合约：exchange.SetContractType("this_week")。
  设置为次周合约：exchange.SetContractType("next_week")。
  设置为季度合约：exchange.SetContractType("quarter")。
  设置为次季合约：exchange.SetContractType("next_quarter")。
  设置为永续合约：exchange.SetContractType("swap")。
  支持以USDT作为保证金的合约。以BTC合约为例，调用exchange.IO("currency", "BTC_USDT")即可切换为以USDT作为保证金的合约，
  或在配置实盘参数、添加交易所对象时直接将当前交易对设置为BTC_USDT。切换交易对后需重新调用exchange.SetContractType()函数设置合约。

• Futures_Deribit
  设置为永续合约：exchange.SetContractType("swap")。
  支持Deribit的USDC合约。
  交割合约有："this_week", "next_week", "month", "quarter", "next_quarter", "third_quarter", "fourth_quarter"。
  差价合约（future_combo）："this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week"等多种组合。
  对于期权合约，需要传入交易所定义的具体期权合约代码，详情请参阅Deribit官网。

• Futures_KuCoin
  币本位合约：例如将交易对设置为BTC_USD，再设置合约代码，即为币本位合约。
  设置为永续合约：exchange.SetContractType("swap")。
  设置为当季合约：exchange.SetContractType("quarter")。
  设置为次季合约：exchange.SetContractType("next_quarter")。

  以USDT作为保证金的合约：
  例如将交易对设置为BTC_USDT，再设置合约代码，即为以USDT作为保证金的合约。
  设置为永续合约：exchange.SetContractType("swap")。

• Futures_Binance
  币安期货交易所默认为当前交易对的永续合约，合约代码：swap。
  设置为永续合约：exchange.SetContractType("swap")。币安的永续合约支持以USDT作为保证金，例如BTC的USDT本位永续合约，需将交易对设置为BTC_USDT；币安也支持以币作为保证金的永续合约，例如BTC的币本位永续合约，需将交易对设置为BTC_USD。
  设置为季度合约：exchange.SetContractType("quarter")。交割合约包含币本位合约（即以币作为保证金），例如设置BTC的季度合约时，将交易对设置为BTC_USD，再调用exchange.SetContractType("quarter")，即可设置为BTC的币本位季度合约。
  设置为次季合约：exchange.SetContractType("next_quarter")。例如设置BTC的币本位次季度合约时，将交易对设置为BTC_USD，再调用exchange.SetContractType("next_quarter")。
  币安支持部分以USDT作为保证金的交割合约，以BTC为例，将交易对设置为BTC_USDT，再设置合约代码即可。

  支持币安期权合约：
  期权合约代码格式以交易所定义的为准，例如BTC-241227-15000-C、XRP-240112-0.5-C、BTC-241227-15000-P。以币安期权合约代码BTC-241227-15000-P为例：BTC为期权币种代码，241227为行权日期，15000为行权价格，P表示看跌期权，C表示看涨期权。
  期权的具体类型（欧式期权或美式期权）可查阅交易所期权合约的相关资料。
  交易所可能对期权卖方有所限制，需单独申请资格。币安期权即需要申请卖方资格。

• Futures_Bibox
  Bibox永续合约的合约代码：swap。
  设置为永续合约：exchange.SetContractType("swap")。

• Futures_Bybit
  默认为当前交易对的永续合约，合约代码：swap。
  当周合约代码：this_week。
  次周合约代码：next_week。
  第三周合约代码：third_week。
  月度合约代码：month。
  次月合约代码：next_month。
  季度合约代码：quarter。
  次季度合约代码：next_quarter。
  第三季度合约代码：third_quarter。
  直接使用交易所的合约命名：例如ETHUSDT-04APR25。由于bybit交易所的部分合约品种并无明确的周期性，因此直接使用交易所定义的合约代码进行命名。

• Futures_Kraken
  默认为当前交易对的永续合约，合约代码：swap。
  swap：永续合约。
  month：当月合约。
  quarter：季度合约。
  next_quarter：次季合约。
  third_quarter：第三季度合约。
  swap_pf：混合保证金永续合约。
  quarter_ff：混合保证金季度合约。
  month_ff：混合保证金当月合约。
  next_quarter_ff：混合保证金次季度合约。
  third_quarter_ff：混合保证金第三季度合约。
  直接使用交易所的合约命名：例如FF_ETHUSD_250307。由于Kraken交易所的部分合约品种并无明确的周期性，因此直接使用交易所定义的合约代码进行命名。

• Futures_Bitfinex
  默认为当前交易对的永续合约，合约代码：swap。

• Futures_Bitget
  默认为当前交易对的永续合约，合约代码：swap。
  将交易对设置为BTC_USD即为币本位合约，将交易对设置为BTC_USDT即为USDT结算的合约。模拟合约可将交易对设置为SBTC_USD、BTC_SUSDT。

• Futures_dYdX (v4)
  dYdX永续合约的合约代码：swap。
  设置为永续合约：exchange.SetContractType("swap")。dYdX仅有USD.swap品种维度，使用的保证金为USDC。

• Futures_MEXC
  MEXC（抹茶）永续合约的合约代码：swap。
  设置为永续合约：exchange.SetContractType("swap")。将交易对设置为BTC_USD即为币本位合约，将交易对设置为BTC_USDT即为USDT结算的合约。

• Futures_Crypto
  crypto.com交易所账户中的代币可折算为以USD计价的额度，用作合约交易的保证金。
  设置为永续合约：exchange.SetContractType("swap")。例如，将交易对设置为BTC_USD时，调用exchange.SetContractType("swap")函数即可设置BTC的永续合约。
  crypto.com交易所的交割合约为月度合约，合约代码如下（一月至十二月）：

  
              code
              
              
  "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
  

  设置交割合约：exchange.SetContractType("October")。例如，将交易对设置为BTC_USD时，调用exchange.SetContractType("October")函数即可设置BTC的十月交割合约。
  当前时刻对应的合约代码为BTCUSD-231027。

• Futures_WOO
  Futures_WOO交易所支持USDT本位合约，永续合约代码为swap。例如，将交易对设置为BTC_USDT时，调用exchange.SetContractType("swap")函数即可将当前合约设置为BTC的USDT本位永续合约。

• Futures_Hyperliquid
  Futures_Hyperliquid交易所支持USDC本位合约，永续合约代码为swap。例如，将交易对设置为ETH_USD时，调用exchange.SetContractType("swap")函数即可将当前合约设置为ETH的USDC本位永续合约。
  Futures_Hyperliquid仅有USD.swap品种维度，使用的保证金为USDC。
  Futures_Hyperliquid支持HIP-3品种。

• Futures_Lighter
  Futures_Lighter交易所支持USDC本位合约，永续合约代码为swap。例如，将交易对设置为BTC_USDC时，调用exchange.SetContractType("swap")函数即可将当前合约设置为BTC的USDC本位永续合约。
  Futures_Lighter仅支持永续合约。

• Futures_Backpack
  Futures_Backpack交易所支持USDC本位合约，永续合约代码为swap。例如，将交易对设置为ETH_USDC时，调用exchange.SetContractType("swap")函数即可将当前合约设置为ETH的USDC本位永续合约。

• Futures_edgeX
  Futures_edgeX交易所支持USDT本位合约，永续合约代码为swap。例如，将交易对设置为BTC_USDT时，调用exchange.SetContractType("swap")函数即可将当前合约设置为BTC的USDT本位永续合约。

• Futures_WOOFI
  Futures_WOOFI交易所支持USDC本位合约，永续合约代码为swap。例如，将交易对设置为ETH_USDC时，调用exchange.SetContractType("swap")函数即可将当前合约设置为ETH的USDC本位永续合约。

• Futures_Coinw
  Futures_Coinw交易所支持USDT本位合约，永续合约代码为swap。例如，将交易对设置为ETH_USDT时，调用exchange.SetContractType("swap")函数即可将当前合约设置为ETH的USDT本位永续合约。

• Futures_Aster
  Futures_Aster交易所支持USDT本位合约，永续合约代码为swap。例如，将交易对设置为ETH_USDT时，调用exchange.SetContractType("swap")函数即可将当前合约设置为ETH的USDT本位永续合约。

• Futures_DeepCoin
  币本位合约：例如将交易对设置为BTC_USD，再设置合约代码，即为币本位合约。
  设置为永续合约：exchange.SetContractType("swap")。

  以USDT作为保证金的合约：
  例如将交易对设置为BTC_USDT，再设置合约代码，即为以USDT作为保证金的合约。
  设置为永续合约：exchange.SetContractType("swap")。

exchange.GetContractType

exchange.GetContractType()函数用于获取exchange交易所对象当前设置的合约代码。

    
    
    
exchange.GetContractType()

示例

    javascript
    
    
function main () {
    Log(exchange.SetContractType("this_week"))
    Log(exchange.GetContractType())
}

    python
    
    
def main():
    Log(exchange.SetContractType("this_week"))
    Log(exchange.GetContractType())

    rust
    
    
fn main() {
    Log!(exchange.SetContractType("this_week"));
    Log!(exchange.GetContractType());
}

    c++
    
    
void main() {
    Log(exchange.SetContractType("this_week"));
    Log(exchange.GetContractType());
}

返回值

参考

exchange.GetFundings

exchange.GetFundings()函数用于获取当前周期的资金费率数据。

    
    
    
exchange.GetFundings()

    
    
    
exchange.GetFundings(symbol)

示例

使用期货交易所对象，在回测系统中调用exchange.GetFundings()函数。在调用任何行情函数之前，GetFundings 仅返回当前默认交易对的 Funding 数据；在调用行情函数之后，则会返回所有已请求过的品种的 Funding 数据。可参考以下测试示例：

    javascript
    
    
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/

function main() {
    // LPT_USDT.swap 4小时周期
    var symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
    for (var symbol of symbols) {
        exchange.GetTicker(symbol)
    }

    var arr = []
    var arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
    for (var p of arrParams) {
        if (p == "no param") {
            arr.push(exchange.GetFundings())
        } else {
            arr.push(exchange.GetFundings(p))
        }
    }

    var tbls = []
    var index = 0
    for (var fundings of arr) {
        var tbl = {
            "type": "table",
            "title": arrParams[index],
            "cols": ["Symbol", "Interval", "Time", "Rate"],
            "rows": [],
        }

        for (var f of fundings) {
            tbl["rows"].push([f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate * 100 + " %"])
        }
        tbls.push(tbl)
        index++
    }

    LogStatus(_D(), "\n Requested symbols:", symbols, "\n`" + JSON.stringify(tbls) + "`")
}

    python
    
    
'''backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
'''

import json

def main():
    # LPT_USDT.swap 4小时周期
    symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
    for symbol in symbols:
        exchange.GetTicker(symbol)

    arr = []
    arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
    for p in arrParams:
        if p == "no param":
            arr.append(exchange.GetFundings())
        else:
            arr.append(exchange.GetFundings(p))

    tbls = []
    index = 0
    for fundings in arr:
        tbl = {
            "type": "table",
            "title": arrParams[index],
            "cols": ["Symbol", "Interval", "Time", "Rate"],
            "rows": [],
        }

        for f in fundings:
            tbl["rows"].append([f["Symbol"], f["Interval"] / 3600000, _D(f["Time"]), str(f["Rate"] * 100) + " %"])

        tbls.append(tbl)
        index += 1

    LogStatus(_D(), "\n Requested symbols:", symbols, "\n`" + json.dumps(tbls) + "`")

    rust
    
    
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/

fn main() {
    // LPT_USDT.swap 4小时周期
    let symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"];
    for symbol in symbols {
        exchange.GetTicker(symbol);
    }

    let mut arr: Vec<Vec<Funding>> = Vec::new();
    let arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"];
    for p in arrParams {
        if p == "no param" {
            arr.push(exchange.GetFundings(None).unwrap());
        } else {
            arr.push(exchange.GetFundings(p).unwrap());
        }
    }

    // Rust SDK 没有JSON序列化，使用format!拼接表格的JSON文本
    let mut tbls: Vec<String> = Vec::new();
    for (index, fundings) in arr.iter().enumerate() {
        let mut rows: Vec<String> = Vec::new();
        for f in fundings {
            rows.push(format!(r#"["{}", {}, "{}", "{} %"]"#, f.Symbol, f.Interval as f64 / 3600000.0, _D(f.Time), f.Rate * 100.0));
        }
        let tbl = format!(r#"{{"type": "table", "title": "{}", "cols": ["Symbol", "Interval", "Time", "Rate"], "rows": [{}]}}"#, arrParams[index], rows.join(","));
        tbls.push(tbl);
    }

    LogStatus!(_D(None), "\n Requested symbols:", format!("{:?}", symbols), format!("\n`[{}]`", tbls.join(",")));
}

    c++
    
    
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/

void main() {
    // LPT_USDT.swap 4小时周期
    json arrSymbol = R"([])"_json;
    std::string symbols[] = {"SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"};
    for (const std::string& symbol : symbols) {
        exchange.GetTicker(symbol);
        arrSymbol.push_back(symbol);
    }

    std::vector<std::vector<Funding>> arr = {};
    std::string arrParams[] = {"no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"};
    for (const std::string& p : arrParams) {
        if (p == "no param") {
            arr.push_back(exchange.GetFundings());
        } else {
            arr.push_back(exchange.GetFundings(p));
        }
    }

    json tbls = R"([])"_json;
    int index = 0;
    for (int i = 0; i < arr.size(); i++) {
        auto fundings = arr[i];

        json tbl = R"({
            "type": "table",
            "cols": ["Symbol", "Interval", "Time", "Rate"],
            "rows": []
        })"_json;
        tbl["title"] = arrParams[index];

        for (int j = 0; j < fundings.size(); j++) {
            auto f = fundings[j];
            // json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), string(f.Rate * 100) + " %"};
            json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate};
            tbl["rows"].push_back(arrJson);
        }
        tbls.push_back(tbl);
        index++;
    }

    LogStatus(_D(), "\n Requested symbols:", arrSymbol.dump(), "\n`" + tbls.dump() + "`");
}

返回值

参数

参考

备注

对于不支持批量查询资金费率数据的期货交易所，若将symbol参数指定为查询范围（例如USDT.swap）或不传入symbol参数，接口将会报错。使用这类期货交易所对象调用GetFundings()函数时，必须将symbol参数指定为具体的某个永续合约品种，才能查询到该品种的当期资金费率数据。

exchange.GetFundings()函数支持实盘与回测系统。

不支持批量获取资金费率数据的交易所：Futures_Bitget、Futures_OKX、Futures_MEXC、Futures_Deribit、Futures_Crypto。调用时需传入symbol参数指定具体的品种代码，例如：ETH_USDT.swap。

不支持exchange.GetFundings()函数的交易所：