一、套利原理- `* X5 v5 {3 f$ W% ?9 i
1 S0 Q0 h7 A( }; g; m
以下就是汇总一下，以数字货币为例，举例BTC币本位（币安目前U本位交割合约除了BTC没有其他品种），蝶式套利涉及三个合约，BTC永续、BTC当季、BTC次季三个合约，计算价差公式为：价差=次季+永续-2*当季，当价差偏低时进行价差做多，则永续做多1份、次季做多1份，当季做空2份，当价差偏高时进行价差做空，则永续做空1份、次季做空1份，当季做多2份，以下为举例
* {) }( K9 R2 l( M. `) I| EOS | 永续价格 | 次季价格 | 当季价格 | 价差 | 盈利 | | 当前价格（参考做多价差阈值为1， 做空价差阈值为-1） | 7 | 9 | 8 | 0 | | 偏移参考价差进行做多，当价差平多时 | 8 | 10 | 8.5 | 1 | 1 | | 偏移参考价差进行做空，当价差平空时 | 6 | 8 | 7.5 | -1 | 1 |
根据上面例子来看当价差不断向外扩偏移不回归的时候，可将价差加仓变成对应的网格加仓，我自己目前是将价差求一个EMA价差，然后设置阈值，通过当前价差与EMA价差的差值跟阈值进行比较判断是否价差开仓。
1 l0 h% W! H R, ?8 r# n" _| EOS/方向 | EMA价差 | 价差 | 阈值 | 单仓份数 | 总份数 | | 价差做空 | 10 | 14 | 2 | 2 | 8 | | 价差做多 | 10 | 8 | 2 | 1 | 4 |
根据上表看出开仓总份数是单个的4倍，主要是永续、次季各一份，当季占两份，阈值设置可自行调整，自己设置的阈值公式为=手续费x合约均价x16，当手续费设置过小时阈值也小. ~! y' F% V6 g* A
二、伪代码流程8 K0 H( z1 v" x/ I* |' q
- W1 j( Q. Q0 P8 b% Q& E7 @3 T
伪代码的原因是由于没有自己使用ccxt比较抱歉，目前自己的该程序是订阅websocket 1分钟以及ticker通道，当1分钟数据推送的时候进行一些条件判断，使用rest api直接定时运行即可，以下内容我是将自己代码主程序改成伪代码形式5 r9 i1 i. X0 C4 h# \
# 永续 次季 当季
% @3 h& ?0 {& E' @5 P7 USWAP_time = 永续时间 # 通过获取最后一根K线判断
7 \$ U) ~- f" [+ H% @NQ_time = 次季时间 # 通过获取最后一根K线判断: \ T F" P( b/ g# i% U* O
CQ_time = 当季时间 # 通过获取最后一根K线判断
! j) z3 B1 v- n+ X2 g8 \if (pd.to_datetime(SWAP_time) == pd.to_datetime(CQ_time)) and (pd.to_datetime(SWAP_time) == pd.to_datetime(NQ_time)):$ N: V7 u+ d! k5 q7 H
# 永续仓位
4 O$ O, ]" n$ Q1 Q6 l8 s swap_pos = 永续合约仓位方向
3 T' s3 k }# B- `; s) b% \ # 次季仓位# c& ^; ]" g) ?# h9 E4 b
nq_pos = 次季合约仓位方向# e" P: j, W/ t' |. m9 x7 _
# 当季仓位
[4 D2 o( a0 K! f7 I3 D2 n5 ^7 c cq_pos = 当季合约仓位方向
9 Y* ]6 p. q$ w" ^% T now_diff_price = 永续价格 + 次季价格 - 2 * 当季价格 # 通过ticker可得: q" N9 G3 d( {" ^9 }
if swap_pos == 0 and nq_pos == 0 and cq_pos == 0: # 当不持仓- k% @3 I, U7 C$ o$ D9 t
# 当三者时间相对时进行判断
$ Q$ v+ P2 j6 S8 v- c8 Y if self.last_diff_price is None: # 当价差不存在时进行价差计算 永续+次季 - 2 * 当季
: e1 p2 Z- X2 e1 J5 s# T) j diff_price = (self.records[self.symbols[0]]['close'] + self.records[self.symbols[1]]['close']) - 2 * \
) u. d$ ^) P# N( \ self.records[self.symbols[2]]['close']
" O5 c# d ^: q" j8 v # 进行价差平均/ b0 a2 B2 M U$ U# v
diff_price_mean = diff_price.ewm(self.windows, adjust=False).mean() # 求价差EMA% D3 v% c' { F+ t
self.last_diff_price = diff_price_mean.iloc[-1] # 记录当前价差平均. I: K& \/ F* t- y$ K' h8 ]) V
avg_price = 三个合约均价- d& ^& T8 u& L$ Z' V- `& Q2 ~+ y
self.diff_threshold = self.fee * avg_price * 16 # 计算阈值
9 i$ o4 q' h, N, \# G9 D
; O$ [7 B. [- p- p5 x' x9 v amount = int((now_diff_price - self.last_diff_price) / self.diff_threshold) # 计算份数
- [2 s, ^6 A! Y/ Z, d) m X* c if amount >= 1: # 当大于一份进行做空5 t# U% ~ Y! c
contract_size = 合约面值大小 # BTC 100U 其余差不多都是10U
4 K( ]" N3 i% |: |% E" H balance = 对应的币本位的数量 * 对应币的价格 # 换算USDT
3 Y% C& g4 b9 f9 p# D* _ # 计算下单份数: A( w$ ~6 s# s4 q! I
contract_num = int(balance / (4 * contract_size)) # 可开张数
: _8 T: l* {7 }4 ? # 计算永续实际开单进行做空
& T; Z C# e% M* r9 `& h6 X price = 永续ticker价格 需要进行精度处理
: @6 O4 Z. p; v) w* |5 w # 永续做空 下单量为 contract_num * amount0 Y& l+ h3 {+ C8 P
做空下单函数
2 v8 w: ]- Q2 H. q$ h+ z& x# { V, r0 W( U5 C0 x, A0 z
# 计算次季实际开单进行做空
. q1 C7 i3 {; r+ W6 [& I price = 次季ticker价格 需要进行精度处理
3 B* a8 s5 C1 W9 {& k! [2 O) L # 次季做空 下单量为 contract_num * amount
; K0 j; g( n$ T% X8 }8 p, f$ r 做空下单函数
3 L) J+ ]% Z8 V/ z: m8 q: x" o) }* O0 J
# 计算当季实际开单进行做多 2份
& t; k! ] Y4 d7 ^, k7 o" V, b5 | price = 当季ticker价格 需要进行精度处理' A7 H; T) i, c; u8 ^2 N" p
# 当季做多 下单量为 contract_num * amount * 2, T" [* X+ p8 ]
做多下单函数
; N8 i6 `7 i$ `7 y self.pos_diff_price = None
. R' V: K! g0 G" l6 `0 D1 d( N x- ^- a msg = f"价差套利进行做空，当前价差为:{now_diff_price}, 价差均值为:{self.last_diff_price}, 开仓份数:{amount}, 价差阈值:{self.diff_threshold}"
) J2 C/ s j: K logger.info(msg, caller=self)
* z( ]( j# O/ b8 o& ` elif amount <= -1: # 做多* ~, v" B5 _% U2 S( w5 T
contract_size = 合约面值大小 # BTC 100U 其余差不多都是10U, p& s1 ~$ O9 T. }0 }9 T5 \
balance = 对应的币本位的数量 * 对应币的价格 # 换算USDT& K+ A4 a/ L- [/ }
# 计算下单份数
1 b n) Z% G% q/ ^& Z {1 D3 r contract_num = int(balance / (4 * contract_size)) # 可开张数5 C9 [- t* M" x0 |7 ?$ Z: u2 g
# 计算永续实际开单进行做多( }6 t0 P% y8 |. }
price = 永续ticker价格 需要进行精度处理
; w" o% q+ O! ? # 永续做多 下单量为 contract_num * amount. V+ i; t7 \8 o' _( @
做多下单函数0 f$ k# u7 q7 T2 e
, ^# [% h- z! J5 Y" [; U# y' F3 Z/ n! ^
# 计算次季实际开单进行做多' b6 }5 p p% \* {
price = 次季ticker价格 需要进行精度处理7 M) B1 N: Z$ C, B/ v
# 次季做多 下单量为 contract_num * amount
0 \# I4 I# \4 d3 a8 ~ 做多下单函数 G# ~% ]9 D. O A
; a0 o% _8 W5 L( ` # 计算当季实际开单进行做空 2份/ ~. V1 u( s" o$ t5 \. f. h
price = 当季ticker价格 需要进行精度处理
4 N. X7 T: Y$ Y # 当季做空 下单量为 contract_num * amount * 2
- O1 T9 W7 [- d# V+ A$ g6 h7 I 做空下单函数0 B6 e3 q) P; [1 L# ?
self.pos_diff_price = None
, I$ c. p7 G' T4 Y- X/ }" E' { msg = f"价差套利进行做多，当前价差为:{now_diff_price}, 价差均值为:{self.last_diff_price}, 开仓份数:{amount}, 价差阈值:{self.diff_threshold}"
3 x# ]3 S$ h2 v+ l3 z logger.info(msg, caller=self)* R# A, r2 a8 s
self.add_pos_count = 0) w( |: e7 f' K* d
msg = f'当前仓位为空仓，当前价差为:{now_diff_price}, 价差均值为:{self.last_diff_price}, 是否加仓:{amount}, 价差阈值:{self.diff_threshold}') n% {) h" c. E0 P2 Y# Q, ]
logger.info(msg, caller=self)
' O* ^ |- ~% G p: A/ {% K' I! A elif swap_pos == 1 and nq_pos == 1 and cq_pos == -1: # 套利做多情况# {1 p0 t6 C" ~' U, O! w
if self.pos_diff_price is None: # 当持仓实际价差不存在时+ |1 |1 o, o" L- X6 R' u
# 永续仓位均价
. @" @9 K% K _- T1 B1 @, }7 d swap_price = 永续仓位持仓均价/ w6 k+ V5 M" V1 b9 h2 m
# 次季仓位均价
' b0 w+ [9 u8 a( L5 u7 a* Q1 q$ R nq_price = 次季仓位持仓均价
% r% M: A8 h6 A* A$ c # 当季仓位均价
! C# _6 K2 y W( t cq_price = 当季仓位持仓均价 E2 {2 Z4 h" I7 m1 s/ e0 E) C8 u+ L
self.pos_diff_price = swap_price + nq_price - 2 * cq_price
+ N4 Q) @( a. i" B5 r6 |/ A4 h0 M1 g8 g2 P, G
amount = int((now_diff_price - self.pos_diff_price) / self.diff_threshold) # 计算当前价差与持仓价差 判断是否加仓平仓
. M5 J. u; d0 a, V6 L9 S h$ a if amount >= 1: # 套利平仓平多0 E( _$ k4 F0 s4 T
# 计算永续实际开单进行平多
( T( }: K3 |/ N5 M( I; H quantity_swap = 永续持仓量; C; S; a! l i; q6 L
price = 永续ticker价格 需要进行精度处理; a' O; K- ^ ]" N+ P# j
# 永续平多 平仓量quantity_swap! ^' k6 f% J* ^
平多下单函数3 t* N; ]" {; I! P& x
* O1 P( H1 [2 i' Q% t
# 计算次季实际开单进行平多8 _- s6 s; F9 O
quantity_nq = 次季持仓量
x! S, w/ [( m price = 次季ticker价格 需要进行精度处理; k" ~" g5 w# m$ d
平多下单函数" }, E! c. i v7 r& s
, ^/ K$ h1 {" I # 计算当季实际开单进行平空, B7 q# l4 j4 o
quantity_cq = 当季持仓量) k: m. S; _4 I5 Q$ X C! B+ s
price = 当季ticker价格 需要进行精度处理% [6 a6 @* Q( _4 ^
平空下单函数) N& o* o( D+ V- J6 i4 m1 l
self.last_diff_price = None. m7 ]% s& v9 l
msg = f"价差套利进行平空，当前价差为:{now_diff_price}, 仓位价差为:{self.pos_diff_price}, 开仓份数:{amount}, 价差阈值:{self.diff_threshold}"
8 R/ I' T0 k+ ]2 h8 v2 c: c logger.info(msg, caller=self): N. h2 S" P8 j, x E
elif amount <= -1: # 加仓做多, j1 x" s, e# ^! f
if self.add_pos_count < 2: # 设置加仓次 设置可加仓几次 若加仓次数太多会导致爆仓/ a' D6 a- n4 v' B$ h4 Z) @- K. V
contract_size = 合约面值大小 # BTC 100U 其余差不多都是10U5 e: O( z$ \7 C: p+ l4 Q
balance = 对应的币本位的数量 * 对应币的价格 # 换算USDT( a9 l, N1 \* G2 x$ H3 {
# 计算下单份数
& K# K4 ]3 m1 R# A contract_num = int(balance / (4 * contract_size)) # 可开张数
$ c2 O9 i% k$ t, U0 _ # 计算永续实际开单进行做多/ \3 r' ]7 @5 S: b0 b0 D
price = 永续ticker价格 需要进行精度处理% }5 p. I. b0 ~, I4 J; L
4 F4 z+ H9 U- K) }: C # 永续做多 下单量为 contract_num * amount
5 A3 I+ m/ G* V 做多下单函数
- p9 P' A" i1 b
) V% J6 s; \/ K v; i # 计算次季实际开单进行做多9 F- b$ L, ]: o9 p4 a7 Z3 N0 R
price = 次季ticker价格 需要进行精度处理
7 P# Q; _9 Y* [3 _6 \ n+ i$ m2 r. \, I: g I$ x2 g
# 次季做多 下单量为 contract_num * amount
9 X8 e8 b# j) `0 l- @4 G6 e& X& G 做多下单函数# w6 _, s5 K3 U/ o! X
" ~5 g. u2 x) @) Y% v/ B2 K # 计算当季实际开单进行做空 2份4 l' Q5 }; Q( w: t2 ^
price = 当季ticker价格 需要进行精度处理8 H. [7 b, O: l2 I9 M
# 当季做空 下单量为 contract_num * amount * 21 i9 k" v% o$ k7 ~
做空下单函数
/ [3 k4 M, G# j self.add_pos_count += 1& m* l$ C& z- h& f3 T% G* F0 H+ w5 j
msg = f'套利价差做多进行加仓，当前次数为{self.add_pos_count}'
5 B5 p+ X1 L3 |5 G logger.info(msg, caller=self)
6 f8 s @9 J! Q5 } msg = f'当前仓位为做多仓位，当前价差为:{now_diff_price}, 仓位价差为:{self.pos_diff_price}, 是否加仓:{amount}， 价差阈值:{self.diff_threshold}'
$ W' p) S: R z; Z4 | logger.info(msg, caller=self)+ A8 e5 v- S+ v& G# L) {2 B
) j, [) U8 B1 O+ X+ D" \( L elif swap_pos == -1 and nq_pos == -1 and cq_pos == 1: # 套利做空情况5 H! t+ q4 I, }& B2 I7 e% |0 U
if self.pos_diff_price is None: # 当持仓实际价差不存在时4 l( I+ g+ J6 p& T
# 永续仓位均价
! c* F0 u: ?' Y7 Q! z$ y swap_price = self.symbol_position_order_info.loc[condition_swap, "持仓均价"].iloc[0]
. |8 R: v) a4 x # 次季仓位均价
: Z* H, i% @2 y$ N( h+ f4 _+ S V nq_price = self.symbol_position_order_info.loc[condition_nq, "持仓均价"].iloc[0]
( W3 M4 J# T; H; X; w # 当季仓位均价5 `5 u6 n0 `3 N- k4 g
cq_price = self.symbol_position_order_info.loc[condition_cq, "持仓均价"].iloc[0]. m5 ^8 ^ y8 B# J. T: a( a
self.pos_diff_price = swap_price + nq_price - 2 * cq_price
! y$ }$ J8 ?9 r' K! _% L/ D2 j' h# W0 J2 V: W7 I' W+ S
amount = int((now_diff_price - self.pos_diff_price) / self.diff_threshold)
, `; b* {" b8 W8 G1 y5 c if amount <= -1: # 套利平仓平空& |( M4 F: v! h1 y2 Y6 g' h4 }
# 计算永续实际开单进行平空做多1 _+ e( `9 B" c! J% z
quantity_swap = 永续持仓量
X! Q* O& B2 d+ l8 x3 w. J
2 N( n* f7 d' K price = 永续ticker价格 需要进行精度处理
. z; }7 v4 w1 z 平空下单函数
4 g- b8 a1 N' q, C+ ]& L9 K- o$ A' M: {
# 计算次季实际开单进行平空做多( W, ]) ]9 `$ B* _) S5 I9 O+ L- d
quantity_nq = 次季持仓量
' V3 ]/ l B6 U1 q2 z price = 次季ticker价格 需要进行精度处理
/ b" Z9 V @, G/ y& ` 平空下单函数
+ } N' r/ F0 X
) D& l# {- C* B6 W% T9 `. R # 计算当季实际开单进行平多做空
7 }7 l( {1 ~4 q' P: k2 Z- z7 g quantity_cq = 当季持仓量
& x8 I* }3 X( \/ H/ Z9 V price = 当季ticker价格 需要进行精度处理
8 ~* r3 R6 N) q k( I* g3 C% Q 平多下单函数
2 @' D8 G, b: @0 y self.last_diff_price = None
& c% F9 f# P! C# h4 _ msg = f"价差套利进行平多，当前价差为:{now_diff_price}, 仓位价差为:{self.pos_diff_price}, 开仓份数:{amount}, 价差阈值:{self.diff_threshold}"
& G+ i: D/ _( J logger.info(msg, caller=self)
% e* l" O4 ?7 ?# w) w1 p: z; B( c elif amount <= 1: # 加仓做空
5 |$ C) i. F% J. F+ w if self.add_pos_count < 2: # 设置加仓次
: h6 H$ c2 j; \1 r- l. }" L contract_size = 合约面值大小 # BTC 100U 其余差不多都是10U
' Q3 M1 u/ B9 V3 E balance = 对应的币本位的数量 * 对应币的价格 # 换算USDT% P* C3 m7 m+ a6 `. J) U- s+ l
# 计算下单份数
; v& L7 S" z# s; H* w contract_num = int(balance / (4 * contract_size)) # 可开张数9 y! r2 n0 @" g" @/ _+ D1 f
# 计算永续实际开单进行做空6 m5 R/ s( S+ Q5 i8 S9 W
price = 永续ticker价格
8 G+ Z7 }& Y* n1 e' G) J$ {! ~ 需要进行精度处理
3 b! |$ d3 r4 X" M, |; O # 永续做空 下单量为 contract_num * amount
* e+ ^/ F" m* w$ D 做空下单函数% J% E9 |3 n" k9 x! B9 _8 s& v& M
& }$ i' X3 [. ^% D" A V
# 计算次季实际开单进行做空
- E/ k7 r. K# S' f/ A6 A7 D price = 次季ticker价格5 J( {( o6 ]" G! p% t- U
需要进行精度处理) X+ g9 z5 w8 r8 j; ]! K; T
# 次季做空 下单量为 contract_num * amount
. p# e, e+ I2 H 做空下单函数
0 B! y+ z5 Y; b7 \9 O
$ i* [, {0 E1 @* M! q' E. s # 计算当季实际开单进行做多 2份: H% S: |- F6 H" C
price = 当季ticker价格4 f) O6 h) y, u) |; e0 A
需要进行精度处理
4 y" ~! Q$ p/ {' A% b! I # 当季做多 下单量为 contract_num * amount * 2
& p" p7 T% n1 Y. Z" p& l 做多下单函数
& ^' R0 Z' O5 i3 R( R" P self.add_pos_count += 1
$ h; Y/ r9 L5 Z' t- R! Z msg = f'套利价差做空进行加仓，当前次数为{self.add_pos_count}'" b7 j3 o. z! M' l9 Z
logger.info(msg, caller=self)
8 d" \; y6 J9 |5 D0 L; b1 u msg = f'当前仓位为做空仓位，当前价差为:{now_diff_price}, 仓位价差为:{self.pos_diff_price}, 是否加仓:{amount}, 价差阈值:{self.diff_threshold}'" a5 A& s3 U$ `+ |) Z2 u
logger.info(msg, caller=self)
; }; k9 F: ]# @6 @2 W) h( s& S else:
8 D% R7 ?5 t* i& s X! m' r msg = '当前持仓有问题，请赶快检查'
% g. \7 ]+ B9 |6 N, O 仓位异常发送钉钉消息 由于下单都是挂单模式 可能会短暂的仓位不平衡情况2 M \- S h- {
三、注意事项- o3 ~" h% L, m
4 }* m5 C8 W: D: e9 q/ x. W/ Q0 Z
1.在币安交易所由于除了BTC有交割合约，其余品种没有交割合约，此策略是在币本位上面运行，目前没有采取对冲模型，纯套利赚币，在OKEX上面则可以直接使用U本位交割合约。
( [4 ~* F0 d: O- F7 A2.选择品种最好采用流动性好的品种，币本位挂单手续费是万1，吃单是万5，若使用吃单模式价差阈值则会变大，造成开仓信号会减少很多，目前在ETH合约进行操作，之前设置手续费为万5时一天都没有交易信号，目前是设置为万2，一天还有几次成交机会
! t; u! }! d, ?% H+ V3.加仓次数不易太多，目前采用的是第一次开仓时1倍杠杆满仓模式，当后面加仓的时候就是变相使用加杠杆
9 R5 g! W7 N. ]' w& N8 y4.挂单模式需要专门一个订单检查模块对订单不断进行检测进行撤单重新挂单处理
* D) G6 P4 G% d/ h; p% y5.持仓信息单位需要在PC端设置为张数，目前仓位检测只是方向检测，如果需要更准确的检测最好是永续仓位+次季仓位=当季仓位
8 R1 c/ V9 `* x! |0 c F四、总结( d9 Y$ [( `4 e) U+ G& O
. p% s2 Y& ^) D2 `7 A F- n3 q3 q3 r刚开始是想通过套利进行刷手续费，但是就目前策略运行来看，频率比较低（ETH每天2-3次机会与吃资金费用差不多），可能选择其他波动大的品种机会会比较多一点，希望有尝试的老板提出其他波动好的品种进行尝试，本次伪代码形式是第一次这样操作，若有不明白以及有误的地方希望有老板指出
1 u8 {: J- ^- ^$ w代码附件:
% q7 _$ e/ q. F$ n4 j2 w
' j2 }, k; V6 F' t. ]
|
提升卡
置顶卡(30天)
沉默卡
喧嚣卡
变色卡
千斤顶
显身卡