从零开始搭建链上dex自动化价差套利程序（10）

最新推荐文章于 2024-10-14 09:08:48 发布

半事无意

最新推荐文章于 2024-10-14 09:08:48 发布

阅读量972

点赞数 15

文章标签： python 数字货币区块链 web3

本文链接：https://blog.csdn.net/weixin_43680481/article/details/134804682

版权

代码整合

btc目前的策略如下：价差超过百1则两边同时make

代码如下：

from init_apex_client import init_client
import asyncio
from send_order_apex import send_order_apex
from init_dydx_client import init_dydx_client
from send_order_dydx import send_order_dydx
from dydx3.constants import MARKET_BTC_USD
from dydx3.constants import ORDER_SIDE_BUY,ORDER_SIDE_SELL
from dydx3.constants import ORDER_TYPE_MARKET
from get_depth_data_btc import calculate_spread
import time

# 初始化apex客户端
client_apex = init_client()
configs = client_apex.configs()
# 获取apex用户和账户信息
client_apex.get_user()
client_apex.get_account()


# 初始化dydx客户端
client_dydx = init_dydx_client()
# 获取我们的dydx仓位 ID
account_response = client_dydx.private.get_account()
position_id = account_response.data['account']['positionId']

async def arbitrage():
  while True:
    # 计算价差
    spread1,spread2 = await calculate_spread()
    # 根据价差判断是否发送交易
    if spread1 > 1:
      currentTime = time.time()
      # 异步地发送一个apex市价卖单和一个dydx市价买单
      limitFeeRate = client_apex.account['takerFeeRate']
      orderResult1, orderResult2 = await asyncio.gather(
        send_order_apex(client_apex, symbol="BTC-USDC", side="SELL",
                                           type="MARKET", size="0.001", expirationEpochSeconds= currentTime,
                                           price="28888.5", limitFeeRate=limitFeeRate),
        send_order_dydx(client_dydx, position_id, MARKET_BTC_USD, ORDER_SIDE_BUY, ORDER_TYPE_MARKET, True, '0.001', '28888', '0.0015', currentTime)
      )
      print(orderResult1)
      print('order_response', orderResult2.data)
    if spread2 > 1:
      currentTime = time.time()
      # 异步地发送一个apex市价买单和一个dydx市价卖单
      limitFeeRate = client_apex.account['takerFeeRate']
      orderResult1, orderResult2 = await asyncio.gather(
        send_order_apex(client_apex, symbol="BTC-USDC", side="BUY",
                                           type="MARKET", size="0.001", expirationEpochSeconds= currentTime,
                                           price="28888.5", limitFeeRate=limitFeeRate),
        send_order_dydx(client_dydx, position_id, MARKET_BTC_USD, ORDER_SIDE_SELL, ORDER_TYPE_MARKET, True, '0.001', '28888', '0.0015', currentTime)
      )
      print(orderResult1)
      print('order_response', orderResult2.data)
    # 延时一秒，避免过于频繁
    await asyncio.sleep(1)

# 运行异步函数
asyncio.run(arbitrage())

bug

dydx发市价单不知道参数怎么设置，文档也不详细，故而改成了发限价单。

还有一些同步异步的问题，要把发交易的函数前加上async。现在修改以及整合的代码部分如下：

1.send_order_apex

from apexpro.helpers.util import round_size

# 定义一个函数，用来发交易
async def send_order_apex(client, symbol, side, type, size, expirationEpochSeconds, price, limitFeeRate):
    # 优化订单的大小和价格
    symbolData = {}
    for k, v in enumerate(client.configs().get('data').get('perpetualContract')):
        if v.get('symbol') == symbol:
            symbolData = v
    size = round_size(size, symbolData.get('stepSize'))
    price = round_size(price, symbolData.get('tickSize'))
    # 创建订单
    createOrderRes = client.create_order(symbol=symbol, side=side,
                                           type=type, size=size, expirationEpochSeconds=expirationEpochSeconds,
                                           price=price, limitFeeRate=limitFeeRate)
    # 返回订单结果
    return createOrderRes

2.send_order_dydx.py

# 定义一个函数，用来发交易
async def send_order_dydx(client, position_id, market, side, order_type, post_only, size, price, limit_fee, expiration_epoch_seconds):
    # 创建订单参数
    order_params = {
        'position_id': position_id,
        'market': market,
        'side': side,
        'order_type': order_type,
        'post_only': post_only,
        'size': size,
        'price': price,
        'limit_fee': limit_fee,
        'expiration_epoch_seconds': expiration_epoch_seconds
    }
    # 创建订单
    order_response = client.private.create_order(**order_params)
    # 返回订单结果
    return order_response.data

3.place_order_btc.py

from init_apex_client import init_client
import asyncio
from send_order_apex import send_order_apex
from init_dydx_client import init_dydx_client
from send_order_dydx import send_order_dydx
from dydx3.constants import MARKET_BTC_USD
from dydx3.constants import ORDER_SIDE_BUY,ORDER_SIDE_SELL
from dydx3.constants import ORDER_TYPE_MARKET,ORDER_TYPE_LIMIT
from get_depth_data_btc import calculate_spread
import time

#价格设置需要更精确，不然发不出去！

# 初始化apex客户端
client_apex = init_client()
configs = client_apex.configs()
# 获取apex用户和账户信息
client_apex.get_user()
client_apex.get_account()


# 初始化dydx客户端
client_dydx = init_dydx_client()
# 获取我们的dydx仓位 ID
account_response = client_dydx.private.get_account()
position_id = account_response.data['account']['positionId']

async def arbitrage():
  while True:
    # 计算价差
    s_first_price_apex,b_first_price_apex,s_first_price_dydx,b_first_price_dydx,s_first_size_apex,b_first_size_apex,s_first_size_dydx,b_first_size_dydx,spread1,spread2 = await calculate_spread()
    # 根据价差判断是否发送交易
    if spread1 > 0.7:
          currentTime = time.time()
          limitFeeRate = client_apex.account['takerFeeRate']
          task_apex_sell = asyncio.create_task(
              send_order_apex(client_apex, symbol="BTC-USDC", side="SELL",
                              type="MARKET", size="0.001", expirationEpochSeconds=currentTime,
                              price=b_first_price_apex, limitFeeRate=limitFeeRate)
          )
          task_dydx_buy = asyncio.create_task(
              send_order_dydx(client_dydx, position_id, MARKET_BTC_USD, ORDER_SIDE_BUY, ORDER_TYPE_LIMIT,
                              True, '0.001', b_first_price_dydx, '0.0015', currentTime+100)
          )

          orderResult1 = await task_apex_sell
          orderResult2 = await task_dydx_buy
          print(orderResult1,orderResult2)
    if spread2 > 0.7: 
      currentTime = time.time()
      # 异步地发送一个apex市价买单和一个dydx市价卖单
      limitFeeRate = client_apex.account['takerFeeRate']
      task_apex_buy = asyncio.create_task(
              send_order_apex(client_apex, symbol="BTC-USDC", side="BUY",
                              type="MARKET", size="0.001", expirationEpochSeconds=currentTime,
                              price=s_first_price_apex, limitFeeRate=limitFeeRate)
          )
      task_dydx_sell = asyncio.create_task(
          send_order_dydx(client_dydx, position_id, MARKET_BTC_USD, ORDER_SIDE_SELL, ORDER_TYPE_LIMIT,
                          True, '0.001', s_first_price_dydx, '0.0015', currentTime+100)
      )

      orderResult1 = await task_apex_buy
      orderResult2 = await task_dydx_sell
      print(orderResult1,orderResult2)
    # 延时一秒，避免过于频繁
    await asyncio.sleep(1)

# 运行异步函数
asyncio.run(arbitrage())

下期介绍一下优化相关