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

最新推荐文章于 2024-09-14 15:44:59 发布

半事无意

最新推荐文章于 2024-09-14 15:44:59 发布

阅读量839

点赞数 16

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

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

版权

今天重构一下代码

1.设置

apexconfig.ini

[apex]
public_key = 
public_key_y_coordinate = 
private_key = 
key = 
secret = 
passphrase =

dydxconfig.ini

[dydx]
eth_private_key =

2.获取价差

get_depth_data_btc.py

"""
这是一个用来计算 APEX 和 dydx 之间的 BTCUSDC 价差的模块。
可以调用 calculate_spread 函数来返回两个交易所的卖一价、买一价和价差。
"""



import asyncio
from apexpro.http_public import HttpPublic
from dydx3 import Client
from dydx3.constants import MARKET_BTC_USD


# 定义交易对列表
symbol = 'BTCUSDC'
market = MARKET_BTC_USD

# 定义异步函数来获取 APEX 的价格
async def get_apex_price():
    # 初始化API客户端
    apexclient = HttpPublic("https://pro.apex.exchange")
    # 获取深度数据
    trades_data = apexclient.depth(symbol=symbol)['data']
    # 返回卖一价和买一价
    return trades_data['a'][0][0], trades_data['b'][0][0], trades_data['a'][0][1], trades_data['b'][0][1]

# 定义异步函数来获取 dydx 的价格
async def get_dydx_price():
    # 初始化API客户端
    dydxclient = Client(host='https://api.dydx.exchange')
    # 获取深度数据
    orderbook_response = dydxclient.public.get_orderbook(market=market)
    orderbook_data = orderbook_response.data
    # 返回卖一价和买一价
    return orderbook_data['asks'][0]['price'], orderbook_data['bids'][0]['price'], orderbook_data['asks'][0]['size'], orderbook_data['bids'][0]['size']

# 定义异步函数来计算价差
async def calculate_spread():
    # 创建两个任务，分别获取 APEX 和 dydx 的价格
    task1 = asyncio.create_task(get_apex_price())
    task2 = asyncio.create_task(get_dydx_price())
    # 等待两个任务完成，并获取结果
    s_first_price_apex, b_first_price_apex,s_first_size_apex,b_first_size_apex = await task1
    s_first_price_dydx, b_first_price_dydx,s_first_size_dydx,b_first_size_dydx   = await task2
    # 计算价差
    spread1 = ((float(s_first_price_apex) - float(b_first_price_dydx))/float(s_first_price_apex))*100
    spread2 = ((float(s_first_price_dydx) - float(b_first_price_apex))/float(s_first_price_dydx))*100
    return 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


if __name__ == '__main__':
    # 创建事件循环
    loop = asyncio.get_event_loop()
    # 运行异步函数
    loop.run_until_complete(calculate_spread())
    # 关闭事件循环
    loop.close()

3.apex

(1)init_apex_client.py

from apexpro.constants import APEX_HTTP_TEST, NETWORKID_TEST, APEX_HTTP_MAIN, NETWORKID_MAIN
from apexpro.http_private_stark_key_sign import HttpPrivateStark
from configparser import ConfigParser

# 定义一个函数，用来初始化客户端
def init_client():
    # 创建配置对象
    config = ConfigParser()
    # 读取配置文件
    config.read('apexconfig.ini')
    # 获取 apex 部分的参数
    public_key = config.get('apex', 'public_key')
    public_key_y_coordinate = config.get('apex', 'public_key_y_coordinate')
    private_key = config.get('apex', 'private_key')
    key = config.get('apex', 'key')
    secret = config.get('apex', 'secret')
    passphrase = config.get('apex', 'passphrase')
    # 创建客户端对象
    client = HttpPrivateStark(
        APEX_HTTP_MAIN,
        network_id=NETWORKID_MAIN,
        stark_public_key=public_key,
        stark_private_key=private_key,
        stark_public_key_y_coordinate=public_key_y_coordinate,
        api_key_credentials={"key": key, "secret": secret, "passphrase": passphrase},
    )
    # 返回客户端对象
    return client

(2)send_order_apex.py

from apexpro.helpers.util import round_size

# 定义一个函数，用来发交易
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

(3)place_order_apex.py

这是测试用代码

from init_apex_client import init_client
from send_order_apex import send_order_apex
import time

# 初始化客户端
client_apex = init_client()
configs = client_apex.configs()

# 获取用户和账户信息
client_apex.get_user()
client_apex.get_account()


# 发送一个市价买单
currentTime = time.time()
limitFeeRate = client_apex.account['takerFeeRate']
orderResult = send_order_apex(client_apex, symbol="BTC-USDC", side="BUY",
                                           type="MARKET", size="0.001", expirationEpochSeconds= currentTime,
                                           price="28888.5", limitFeeRate=limitFeeRate)
print(orderResult)

4.dydx

(1)init_dydx_client.py

from configparser import ConfigParser
from dydx3 import Client

# 定义一个函数，用来初始化客户端
def init_dydx_client():
    # 创建配置对象
    config = ConfigParser()
    # 读取配置文件
    config.read('dydxconfig.ini')
    # 获取 dydx 部分的参数
    eth_private_key = config.get('dydx', 'eth_private_key')
    # 创建客户端对象
    client = Client(host='https://api.dydx.exchange',
                    eth_private_key=eth_private_key,
                    )
    # 设置dydx STARK 密钥
    stark_key_pair_with_y_coordinate = client.onboarding.derive_stark_key()
    client.stark_private_key = stark_key_pair_with_y_coordinate['private_key']
    (public_x, public_y) = (
    stark_key_pair_with_y_coordinate['public_key'],
    stark_key_pair_with_y_coordinate['public_key_y_coordinate'],
    )
    # 返回客户端对象
    return client

(2)send_order_dydx.py

# 定义一个函数，用来发交易
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

(3)place_order_dydx.py

测试用代码

from init_dydx_client import init_dydx_client
from send_order_dydx import send_order_dydx
import time
from dydx3.constants import MARKET_BTC_USD
from dydx3.constants import ORDER_SIDE_BUY,ORDER_SIDE_SELL
from dydx3.constants import ORDER_TYPE_MARKET


# 初始化客户端
client_dydx = init_dydx_client()

# 获取我们的仓位 ID
account_response = client_dydx.private.get_account()
position_id = account_response.data['account']['positionId']

# 发送一个市价买单
currentTime = time.time()
orderResult = send_order_dydx(client_dydx, position_id, MARKET_BTC_USD, ORDER_SIDE_BUY, ORDER_TYPE_MARKET, True, '0.001', '28888', '0.0015', currentTime)
print('order_response',orderResult.data)

最终的整合代码我将在下一期介绍