#!/usr/bin/env python3
"""
马丁递增参数计算器
功能:
- 根据网格参数计算最优的马丁递增值
- 确保每个订单价值都 >= 最小订单价值(默认10 USDC)
- 支持做多和做空网格
- 输出详细的计算过程和验证结果
使用场景:
Lighter交易所要求每笔订单价值 >= 10 USDC。
在网格交易中,价格较低的格子可能导致订单价值不足。
通过马丁递增,逐步增加订单数量,确保所有订单都满足最小价值要求。
作者:网格交易系统
日期:2025-11-08
"""
from decimal import Decimal, ROUND_UP
from typing import Tuple, List
import sys
class MartingaleCalculator:
"""马丁递增参数计算器"""
def __init__(self, min_order_value: Decimal = Decimal('10.0')):
"""
初始化计算器
Args:
min_order_value: 最小订单价值(USDC),默认10
"""
self.min_order_value = min_order_value
def calculate_for_long_grid(
self,
current_price: Decimal,
grid_count: int,
grid_interval: Decimal,
base_quantity: Decimal,
is_percentage: bool = False
) -> Tuple[Decimal, List[dict]]:
"""
计算做多网格的马丁递增参数
做多网格:价格从上到下递减,最低价格的订单价值最小
Args:
current_price: 当前价格
grid_count: 网格数量
grid_interval: 每格间隔(绝对值或百分比)
base_quantity: 基础数量(第一格的数量)
is_percentage: 间隔是否为百分比(True=百分比,False=绝对值)
Returns:
(martingale_increment, grid_details)
- martingale_increment: 马丁递增参数
- grid_details: 每个网格的详细信息(用于验证)
"""
print("\n" + "=" * 80)
print("🔍 做多网格 - 马丁递增参数计算")
print("=" * 80)
# 计算每个格子的价格
grid_prices = []
for i in range(grid_count):
if is_percentage:
# 百分比模式:每格下跌 grid_interval%
price = current_price * (Decimal('1') - grid_interval * i)
else:
# 绝对值模式:每格下跌固定金额
price = current_price - (grid_interval * i)
if price <= 0:
print(f"❌ 错误:第 {i+1} 格价格为负数或零!")
print(f" 建议:减少网格数量或增大价格间隔")
sys.exit(1)
grid_prices.append(price)
# 找到最低价格(做多网格的最后一格)
lowest_price = grid_prices[-1]
print(f"\n📊 网格价格范围:")
print(f" 最高价格(第1格): ${grid_prices[0]:,.6f}")
print(f" 最低价格(第{grid_count}格): ${lowest_price:,.6f}")
print(f" 价格跨度: ${grid_prices[0] - lowest_price:,.6f} ({((1 - lowest_price/grid_prices[0]) * 100):.2f}%)")
# 计算最低价格格子需要的最小数量
min_quantity_at_lowest = self.min_order_value / lowest_price
print(f"\n💰 订单价值计算:")
print(f" 最小订单价值要求: ${self.min_order_value} USDC")
print(f" 基础数量(第1格): {base_quantity}")
print(f" 第1格订单价值: {base_quantity} × ${grid_prices[0]:,.6f} = ${base_quantity * grid_prices[0]:,.2f} USDC")
print(f" ")
print(f" ⚠️ 如果不使用马丁递增:")
print(f" 第{grid_count}格订单价值: {base_quantity} × ${lowest_price:,.6f} = ${base_quantity * lowest_price:,.2f} USDC")
if base_quantity * lowest_price >= self.min_order_value:
print(f" ✅ 无需马丁递增!所有订单价值都 >= ${self.min_order_value} USDC")
return Decimal('0'), []
print(f" ❌ 低于最小要求!")
print(f" ")
print(f" 第{grid_count}格需要的最小数量: {min_quantity_at_lowest:.6f}")
# 计算马丁递增参数
# 公式:quantity_at_lowest = base_quantity + (grid_count - 1) × martingale_increment
# 求解:martingale_increment = (quantity_at_lowest - base_quantity) / (grid_count - 1)
martingale_increment = (min_quantity_at_lowest - base_quantity) / (grid_count - 1)
# 向上取整到合理精度(保留6位小数)
martingale_increment = martingale_increment.quantize(Decimal('0.000001'), rounding=ROUND_UP)
print(f"\n📐 马丁递增参数计算:")
print(f" 公式: martingale_increment = (最低格所需数量 - 基础数量) / (网格数 - 1)")
print(f" 计算: ({min_quantity_at_lowest:.6f} - {base_quantity}) / ({grid_count} - 1)")
print(f" 结果: {martingale_increment}")
# 验证每个格子的订单价值
print(f"\n✅ 验证结果(显示关键格子):")
grid_details = []
critical_grids = [0, grid_count // 4, grid_count // 2, grid_count * 3 // 4, grid_count - 1]
for i in critical_grids:
price = grid_prices[i]
quantity = base_quantity + (martingale_increment * i)
order_value = price * quantity
is_valid = order_value >= self.min_order_value
grid_details.append({
'index': i + 1,
'price': price,
'quantity': quantity,
'order_value': order_value,
'is_valid': is_valid
})
status = "✅" if is_valid else "❌"
print(f" {status} 第{i+1:3d}格: 价格=${price:,.6f}, 数量={quantity:.6f}, "
f"价值=${order_value:,.2f} USDC")
return martingale_increment, grid_details
def calculate_for_short_grid(
self,
current_price: Decimal,
grid_count: int,
grid_interval: Decimal,
base_quantity: Decimal,
is_percentage: bool = False
) -> Tuple[Decimal, List[dict]]:
"""
计算做空网格的马丁递增参数
做空网格:价格从下到上递增,最高价格的订单价值最小(相对而言)
但通常做空网格的问题较小,因为价格上涨时卖单价值更高
Args:
current_price: 当前价格
grid_count: 网格数量
grid_interval: 每格间隔(绝对值或百分比)
base_quantity: 基础数量(第一格的数量)
is_percentage: 间隔是否为百分比
Returns:
(martingale_increment, grid_details)
"""
print("\n" + "=" * 80)
print("🔍 做空网格 - 马丁递增参数计算")
print("=" * 80)
# 计算每个格子的价格
grid_prices = []
for i in range(grid_count):
if is_percentage:
# 百分比模式:每格上涨 grid_interval%
price = current_price * (Decimal('1') + grid_interval * i)
else:
# 绝对值模式:每格上涨固定金额
price = current_price + (grid_interval * i)
grid_prices.append(price)
# 做空网格:最低价格的格子订单价值最小
lowest_price = grid_prices[0]
highest_price = grid_prices[-1]
print(f"\n📊 网格价格范围:")
print(f" 最低价格(第1格): ${lowest_price:,.6f}")
print(f" 最高价格(第{grid_count}格): ${highest_price:,.6f}")
print(f" 价格跨度: ${highest_price - lowest_price:,.6f} ({((highest_price/lowest_price - 1) * 100):.2f}%)")
# 计算最低价格格子需要的最小数量
min_quantity_at_lowest = self.min_order_value / lowest_price
print(f"\n💰 订单价值计算:")
print(f" 最小订单价值要求: ${self.min_order_value} USDC")
print(f" 基础数量(第1格): {base_quantity}")
print(f" 第1格订单价值: {base_quantity} × ${lowest_price:,.6f} = ${base_quantity * lowest_price:,.2f} USDC")
if base_quantity * lowest_price >= self.min_order_value:
print(f" ✅ 无需马丁递增!所有订单价值都 >= ${self.min_order_value} USDC")
return Decimal('0'), []
print(f" ❌ 低于最小要求!")
print(f" 第1格需要的最小数量: {min_quantity_at_lowest:.6f}")
# 做空网格通常不需要马丁递增,因为价格越高订单价值越大
# 但如果第一格就不满足,需要增加基础数量
print(f"\n⚠️ 建议:直接增加基础数量(order_amount)到 {min_quantity_at_lowest:.0f} 以上")
print(f" 做空网格通常不需要马丁递增")
return Decimal('0'), []
def get_decimal_input(prompt: str) -> Decimal:
"""获取 Decimal 类型的输入"""
while True:
try:
value = input(prompt).strip()
return Decimal(value)
except Exception as e:
print(f"❌ 输入无效,请输入数字: {e}")
def get_int_input(prompt: str) -> int:
"""获取整数类型的输入"""
while True:
try:
value = input(prompt).strip()
return int(value)
except Exception:
print(f"❌ 输入无效,请输入整数")
def get_bool_input(prompt: str) -> bool:
"""获取布尔类型的输入"""
while True:
value = input(prompt).strip().lower()
if value in ['y', 'yes', '是', '1', 'true']:
return True
elif value in ['n', 'no', '否', '0', 'false']:
return False
else:
print("❌ 输入无效,请输入 y/n")
def main():
"""主函数"""
print("\n" + "=" * 80)
print("🎯 马丁递增参数计算器(做多网格专用)")
print("=" * 80)
print("功能:计算做多网格的马丁递增参数,确保所有订单价值 >= 10 USDC")
print("=" * 80)
print("\n💡 说明:")
print(" - 做多网格价格向下,低价格订单可能价值不足")
print(" - 做空网格价格向上,不存在此问题,无需马丁递增")
print("=" * 80)
# 初始化计算器
calculator = MartingaleCalculator(min_order_value=Decimal('10.0'))
while True:
print("\n" + "-" * 80)
print("📝 请输入网格参数(做多网格):")
print("-" * 80)
# 固定为做多网格
grid_type = 'long'
# 简化输入:直接提供价格范围
upper_price = get_decimal_input("上限价格(当前价格): ")
lower_price = get_decimal_input("下限价格(最低价格): ")
if lower_price >= upper_price:
print("❌ 错误:下限价格必须小于上限价格!")
continue
grid_count = get_int_input("网格数量: ")
base_quantity = get_decimal_input("基础数量(第一格的代币数量): ")
# 自动计算间隔
current_price = upper_price
price_range = upper_price - lower_price
grid_interval = price_range / grid_count
is_percentage = False
print(f"\n💡 自动计算:")
print(f" 价格区间: ${price_range:.6f} (${lower_price:.6f} ~ ${upper_price:.6f})")
print(f" 每格间隔: ${grid_interval:.6f}")
# 计算
try:
martingale_increment, grid_details = calculator.calculate_for_long_grid(
current_price, grid_count, grid_interval, base_quantity, is_percentage
)
# 5. 输出结果
print("\n" + "=" * 80)
print("🎉 计算完成!")
print("=" * 80)
print(f"\n📋 关键参数:")
print(f" ✅ 网格间隔: {grid_interval}")
print(f" ✅ 马丁递增: {martingale_increment}")
print(f"\n📋 完整配置示例:")
print(f" grid_type: \"martingale_{grid_type}\"")
print(f" grid_interval: {grid_interval}")
print(f" order_amount: {base_quantity}")
print(f" martingale_increment: {martingale_increment}")
print("=" * 80)
except Exception as e:
print(f"\n❌ 计算失败: {e}")
# 6. 是否继续
print("\n")
if not get_bool_input("是否继续计算?(y/n) [默认: n]: "):
break
print("\n👋 感谢使用马丁递增参数计算器!")
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
print("\n\n👋 程序已退出")
except Exception as e:
print(f"\n❌ 程序异常: {e}")
import traceback
traceback.print_exc()