exchange.GetFundings()

# 查询所有合约的资金费率
fundings = exchange.GetFundings()

# 查询指定合约的资金费率
funding = exchange.GetFundings("BTC_USDT")

# 获取所有合约的资金费率
fundings = exchange.GetFundings()

Log(f"共 {len(fundings)} 个合约")
for funding in fundings:
    # 只显示费率不为0的合约
    if funding["Rate"] != 0:
        Log(f"合约: {funding['Symbol']}")
        Log(f"  资金费率: {funding['Rate'] * 100:.4f}%")
        Log(f"  结算周期: {funding['Interval'] / 3600000:.0f} 小时")
        
        # 转换下次结算时间
        import datetime
        next_time = datetime.datetime.fromtimestamp(funding['Time'] / 1000)
        Log(f"  下次结算: {next_time}")

# 查询 BTC 永续合约
funding = exchange.GetFundings("BTC_USDT")

if funding:
    Log(f"合约: {funding['Symbol']}")
    Log(f"资金费率: {funding['Rate'] * 100:.4f}%")
    Log(f"结算周期: {funding['Interval'] / 3600000:.0f} 小时")
    
    # 计算距离下次结算的时间
    import time
    current_time = int(time.time() * 1000)
    time_to_funding = (funding['Time'] - current_time) / 1000 / 60
    Log(f"距离下次结算: {time_to_funding:.0f} 分钟")

def monitor_high_funding_rate(threshold=0.001):
    """监控资金费率超过阈值的合约"""
    fundings = exchange.GetFundings()
    
    high_rate_contracts = []
    for funding in fundings:
        if abs(funding["Rate"]) > threshold:
            high_rate_contracts.append({
                "symbol": funding["Symbol"],
                "rate": funding["Rate"] * 100,  # 转换为百分比
                "time": funding["Time"]
            })
    
    # 按费率绝对值排序
    high_rate_contracts.sort(key=lambda x: abs(x["rate"]), reverse=True)
    
    Log(f"发现 {len(high_rate_contracts)} 个高资金费率合约（>{threshold*100}%）：")
    for contract in high_rate_contracts:
        direction = "多付空" if contract["rate"] > 0 else "空付多"
        Log(f"  {contract['symbol']}: {contract['rate']:.4f}% ({direction})")
    
    return high_rate_contracts

# 每小时检查一次
while True:
    monitor_high_funding_rate(threshold=0.001)  # 0.1%
    Sleep(3600000)  # 1小时

def funding_arbitrage_signal():
    """基于资金费率的套利信号"""
    
    # 获取当前持仓
    position = exchange.GetPosition()
    
    # 获取当前合约的资金费率
    contract_type = exchange.GetContractType()
    funding = exchange.GetFundings(contract_type)
    
    if not funding:
        return
    
    rate = funding["Rate"]
    time_to_funding = (funding["Time"] - int(time.time() * 1000)) / 1000 / 60
    
    Log(f"当前资金费率: {rate * 100:.4f}%")
    Log(f"距离下次结算: {time_to_funding:.0f} 分钟")
    
    # 资金费率策略逻辑
    if rate > 0.001:  # 正费率超过 0.1%
        Log("资金费率过高（多方付费），建议做空")
        if len(position) == 0 or position[0]["Type"] == 0:  # 无持仓或多仓
            # 开空仓或平多仓
            pass
    
    elif rate < -0.001:  # 负费率超过 -0.1%
        Log("资金费率过低（空方付费），建议做多")
        if len(position) == 0 or position[0]["Type"] == 1:  # 无持仓或空仓
            # 开多仓或平空仓
            pass
    
    else:
        Log("资金费率正常，无套利机会")

def compare_funding_rates():
    """对比多个交易所的资金费率"""
    
    # 假设配置了多个交易所
    exchanges_list = [exchange, exchange2]  # Binance, Gate.io
    exchange_names = ["Binance", "Gate.io"]
    
    symbol = "BTC_USDT"
    
    for i, ex in enumerate(exchanges_list):
        try:
            funding = ex.GetFundings(symbol)
            if funding:
                Log(f"{exchange_names[i]} {symbol}:")
                Log(f"  资金费率: {funding['Rate'] * 100:.4f}%")
                
                import datetime
                next_time = datetime.datetime.fromtimestamp(funding['Time'] / 1000)
                Log(f"  下次结算: {next_time}")
        except Exception as e:
            Log(f"{exchange_names[i]} 查询失败: {str(e)}")

def funding_rate_alert():
    """资金费率预警系统"""
    
    # 设置预警阈值
    HIGH_RATE = 0.001  # 0.1%
    VERY_HIGH_RATE = 0.005  # 0.5%
    
    fundings = exchange.GetFundings()
    
    for funding in fundings:
        rate = funding["Rate"]
        abs_rate = abs(rate)
        
        if abs_rate >= VERY_HIGH_RATE:
            direction = "多方" if rate > 0 else "空方"
            Log(f"⚠️ 极端费率预警: {funding['Symbol']} 资金费率 {rate*100:.4f}% ({direction}付费)")
            # 这里可以发送通知、停止策略等
            
        elif abs_rate >= HIGH_RATE:
            direction = "多方" if rate > 0 else "空方"
            Log(f"📢 高费率提醒: {funding['Symbol']} 资金费率 {rate*100:.4f}% ({direction}付费)")

# 每30分钟检查一次
while True:
    funding_rate_alert()
    Sleep(1800000)  # 30分钟

try:
    fundings = exchange.GetFundings()
    # 处理数据
except Exception as e:
    Log("查询资金费率失败:", str(e))
    # 现货交易所会抛出异常

# 缓存资金费率数据，避免频繁查询
funding_cache = {}
last_update = 0

def get_funding_rate(symbol):
    global funding_cache, last_update
    current_time = time.time() * 1000
    
    # 每5分钟更新一次
    if current_time - last_update > 300000:
        fundings = exchange.GetFundings()
        for f in fundings:
            funding_cache[f["Symbol"]] = f
        last_update = current_time
    
    return funding_cache.get(symbol)