Chiến lược sắp xếp dài hạn tiền kỹ thuật số dựa trên dây chuyền Brin

Một, tóm tắt

Soros đã đưa ra một đề xuất quan trọng trong cuốn sách của mình năm 1987 về Thuật toán Kiến thuật Tài chính của Liu: Tôi tin rằng giá thị trường luôn luôn sai trong ý nghĩa rằng họ trình bày một quan điểm thiên vị về tương lai. Giả thuyết hiệu quả của thị trường chỉ là một giả định về mặt lý thuyết, thực tế là những người tham gia thị trường không phải lúc nào cũng hợp lý, và tại mỗi thời điểm, người tham gia không thể hoàn toàn có được và giải thích khách quan tất cả các thông tin, và thậm chí cả khi đó là thông tin tương tự, mọi người cũng có phản hồi khác nhau.

2 Nguyên tắc chiến lược

Theo nguyên tắc trên, chúng ta cũng biết rằng trong một thị trường tương lai không hiệu quả, các hợp đồng giao dịch tỷ lệ trong các thời gian khác nhau cũng không phải lúc nào cũng đồng bộ, và giá cả của chúng cũng không hoàn toàn hiệu quả. Vì vậy, dựa trên giá hợp đồng tỷ lệ giao dịch trong các thời gian khác nhau của cùng một chỉ số giao dịch, nếu hai giá xảy ra chênh lệch giá lớn hơn, bạn có thể mua và bán hợp đồng tương lai trong các thời gian khác nhau cùng một lúc, tạo tỷ giá vượt qua hạn. Cũng giống như hợp đồng tương lai hàng hóa, tiền kỹ thuật số cũng có các hợp đồng tỷ giá vượt qua hạn liên quan. OkEX có trên sàn giao dịch như: ETC trong tuần, ETC tuần sau, ETC quý.

Ví dụ, giả sử chênh lệch giá giữa ETC trong tuần và ETC trong quý kéo dài khoảng 5; nếu chênh lệch giá đạt 7 một ngày, chúng ta dự đoán chênh lệch giá sẽ quay trở lại mức 5 trong một thời gian trong tương lai; sau đó có thể bán ETC trong tuần và mua ETC trong quý để xóa chênh lệch giá; và ngược lại. Mặc dù chênh lệch giá này tồn tại, nhưng sự mất thời gian, sự khác biệt về độ chính xác và ảnh hưởng của sự thay đổi giá, lợi nhuận nhân tạo thường tồn tại thông qua nhiều sự không chắc chắn.

Thứ ba, chiến lược logic

Bài viết này sẽ hướng dẫn bạn cách sử dụng các sàn giao dịch định lượng và hợp đồng tương lai ETC trên sàn giao dịch OkEX trong giao dịch tiền kỹ thuật số, bằng một chiến lược đặt cược đơn giản, để chứng minh việc nắm bắt cơ hội đặt cược ngay lập tức, nắm bắt lợi nhuận có thể nhìn thấy được mỗi lần, đồng thời có khả năng rủi ro có thể xảy ra.

Tạo ra một chiến lược giao dịch tiền điện tử dài hạnKhó khăn: Trung bình

Môi trường chiến lược

• Địa chỉ giao dịch: ETH Classic (ETC)
• Dữ liệu chênh lệch giá: ETC trong tuần - ETC quý ((trừ kiểm tra sự hợp nhất)
• Chu kỳ giao dịch: 5 phút
• 头寸匹配：1:1
• Loại giao dịch: cùng giống

Logic chiến lược

• Nếu tài khoản hiện tại không có cổ phiếu và giá chênh lệch thấp hơn boll, bạn sẽ mua ETC trong tuần và bán ETC trong quý.
• Nếu tài khoản hiện tại không có cổ phiếu và giá chênh lệch lớn hơn boll trên đường, bạn sẽ bán ETC trong tuần và mua ETC trong quý.
• Điều kiện đặt cược chênh lệch giá quá mức: Nếu tài khoản hiện tại có nhiều đơn đặt hàng ETC trong tuần và có nhiều đơn đặt hàng ETC hàng quý và giá chênh lệch giá lớn hơn boll trung gian, giá chênh lệch giá quá mức; tức là: bán ETC trong tuần, mua ETC hàng quý.
• Điều kiện làm ngang giá chênh lệch: Nếu tài khoản hiện tại giữ ETC trong tuần và giữ nhiều đơn đặt hàng ETC hàng quý và giá chênh lệch ít hơn boll trung gian, giá chênh lệch ngang giá.

4. Viết khung chiến lược

Dưới đây là một mô tả logic đơn giản về chiến lược giao dịch dài hạn cho tiền kỹ thuật số, vậy làm thế nào để thực hiện ý tưởng của mình trong chương trình? Chúng tôi đã cố gắng xây dựng khuôn khổ trước khi các nhà phát minh định lượng nền tảng giao dịch.

function Data() {}  // 基础数据函数
Data.prototype.mp = function () {}  // 持仓函数
Data.prototype.boll = function () {}  // 指标函数
Data.prototype.trade = function () {}  // 下单函数
Data.prototype.cancelOrders = function () {}  // 撤单函数
Data.prototype.isEven = function () {}  // 处理单只合约函数
Data.prototype.drawingChart = function () {}  // 画图函数

// 交易条件
function onTick() {
    var data = new Data(tradeTypeA, tradeTypeB);  // 创建一个基础数据对象
    var accountStocks = data.accountData.Stocks;  // 账户余额
    var boll = data.boll(dataLength, timeCycle);  // 计算boll技术指标
    data.trade();  // 计算交易条件下单
    data.cancelOrders();  // 撤单
    data.drawingChart(boll);  // 画图
    data.isEven();  // 处理持有单个合约
}

//入口函数
function main() {
    while (true) {  // 进入轮询模式
        onTick();  // 执行onTick函数
        Sleep(500);  // 休眠0.5秒
    }
}

5. Viết chiến lược

Một khung chiến lược có thể dễ dàng được xây dựng bằng cách so sánh các ý tưởng chiến lược và quy trình giao dịch. Toàn bộ chiến lược có thể được đơn giản hóa thành ba bước:

• Những người tham gia vào cuộc họp này nói rằng:
• Nhận và tính toán dữ liệu.
• Đặt đơn và xử lý tiếp theo.

Tiếp theo, chúng ta cần phải điền mã chi tiết cần thiết theo quy trình giao dịch thực tế và chi tiết giao dịch trong khuôn khổ chiến lược.

Xử lý trước giao dịchBước 1: Trong môi trường toàn cầu, tuyên bố các biến toàn cầu cần thiết.

//声明一个配置图表的 chart 对象
var chart = { }

//调用 Chart 函数，初始化图表
var ObjChart = Chart ( chart )

//声明一个空数组，用来存储价差序列
var bars = [ ]

//声明一个记录历史数据时间戳变量
var oldTime = 0

Bước 2: Các tham số bên ngoài của chính sách cấu hình.

// 参数
var tradeTypeA = "this_week"; // 套利A合约
var tradeTypeB = "quarter"; // 套利B合约
var dataLength = 10; //指标周期长度
var timeCycle = 1; // K线周期
var name = "ETC"; // 币种
var unit = 1; // 下单量

Bước 3: Định nghĩa hàm xử lý dữ liệuChức năng dữ liệu cơ bản: Data ()Tạo một cấu trúc hàm Data và xác định thuộc tính bên trong của nó. Bao gồm: dữ liệu tài khoản, dữ liệu nắm giữ, thời gian k-line, giá mua / bán trên hợp đồng A / B, giá dương / ngược.

// 基础数据
function Data(tradeTypeA, tradeTypeB) { // 传入套利A合约和套利B合约
    this.accountData = _C(exchange.GetAccount); // 获取账户信息
    this.positionData = _C(exchange.GetPosition); // 获取持仓信息
    var recordsData = _C(exchange.GetRecords); //获取K线数据
    exchange.SetContractType(tradeTypeA); // 订阅套利A合约
    var depthDataA = _C(exchange.GetDepth); // 套利A合约深度数据
    exchange.SetContractType(tradeTypeB); // 订阅套利B合约
    var depthDataB = _C(exchange.GetDepth); // 套利B合约深度数据
    this.time = recordsData[recordsData.length - 1].Time; // 获取最新数据时间
    this.askA = depthDataA.Asks[0].Price; // 套利A合约卖一价
    this.bidA = depthDataA.Bids[0].Price; // 套利A合约买一价
    this.askB = depthDataB.Asks[0].Price; // 套利B合约卖一价
    this.bidB = depthDataB.Bids[0].Price; // 套利B合约买一价
    // 正套价差(合约A卖一价 - 合约B买一价)
    this.basb = depthDataA.Asks[0].Price - depthDataB.Bids[0].Price;
    // 反套价差(合约A买一价 - 合约B卖一价)
    this.sabb = depthDataA.Bids[0].Price - depthDataB.Asks[0].Price;
}

Nhận hàm giữ:mp ()Chuyển qua toàn bộ mảng giữ, trả về số lượng giữ theo hợp đồng cụ thể, số lượng giữ theo hướng cụ thể, nếu không trả về false

// 获取持仓
Data.prototype.mp = function (tradeType, type) {
    var positionData = this.positionData; // 获取持仓信息
    for (var i = 0; i < positionData.length; i++) {
        if (positionData[i].ContractType == tradeType) {
            if (positionData[i].Type == type) {
                if (positionData[i].Amount > 0) {
                    return positionData[i].Amount;
                }
            }
        }
    }
    return false;
}

Dòng K và hàm chỉ số:boll ()Tạo ra một chuỗi K mới dựa trên dữ liệu chênh lệch giá dương / ngược; và trả về dữ liệu trên đường, giữa đường và dưới đường được tính toán bởi chỉ sốboll.

// 合成新K线数据和boll指标数据
Data.prototype.boll = function (num, timeCycle) {
    var self = {}; // 临时对象
    // 正套价差和反套价差中间值
    self.Close = (this.basb + this.sabb) / 2;
    if (this.timeA == this.timeB) {
        self.Time = this.time;
    } // 对比两个深度数据时间戳
    if (this.time - oldTime > timeCycle * 60000) {
        bars.push(self);
        oldTime = this.time;
    } // 根据指定时间周期，在K线数组里面传入价差数据对象
    if (bars.length > num * 2) {
        bars.shift(); // 控制K线数组长度
    } else {
        return;
    }
    var boll = TA.BOLL(bars, num, 2); // 调用talib库中的boll指标
    return {
        up: boll[0][boll[0].length - 1], // boll指标上轨
        middle: boll[1][boll[1].length - 1], // boll指标中轨
        down: boll[2][boll[2].length - 1] // boll指标下轨
    } // 返回一个处理好的boll指标数据
}

Chức năng dưới:trade ()Nhập tên hợp đồng đặt hàng và loại hợp đồng đặt hàng, sau đó đặt hàng theo giá đối lập và trả về kết quả đặt hàng. Vì cần phải đặt hai đơn hàng theo hai hướng khác nhau cùng một lúc, nên chuyển đổi giá mua / bán theo tên hợp đồng đặt hàng được thực hiện bên trong hàm.

// 下单
Data.prototype.trade = function (tradeType, type) {
    exchange.SetContractType(tradeType); // 下单前先重新订阅合约
    var askPrice, bidPrice;
    if (tradeType == tradeTypeA) { // 如果是A合约下单
        askPrice = this.askA; // 设置askPrice
        bidPrice = this.bidA; // 设置bidPrice
    } else if (tradeType == tradeTypeB) { // 如果是B合约下单
        askPrice = this.askB; // 设置askPrice
        bidPrice = this.bidB; // 设置bidPrice
    }
    switch (type) { // 匹配下单模式
        case "buy":
            exchange.SetDirection(type); // 设置下单模式
            return exchange.Buy(askPrice, unit);
        case "sell":
            exchange.SetDirection(type); // 设置下单模式
            return exchange.Sell(bidPrice, unit);
        case "closebuy":
            exchange.SetDirection(type); // 设置下单模式
            return exchange.Sell(bidPrice, unit);
        case "closesell":
            exchange.SetDirection(type); // 设置下单模式
            return exchange.Buy(askPrice, unit);
        default:
            return false;
    }
}

Hủy lệnh chức năng:cancelOrders ()Lấy tất cả các mảng lệnh chưa hoàn thành và hủy một lần một lần. Và trả về false nếu có lệnh chưa hoàn thành, trả về true nếu không có lệnh chưa hoàn thành.

// 取消订单
Data.prototype.cancelOrders = function () {
    Sleep(500); // 撤单前先延时，因为有些交易所你懂的
    var orders = _C(exchange.GetOrders); // 获取未成交订单数组
    if (orders.length > 0) { // 如果有未成交的订单
        for (var i = 0; i < orders.length; i++) { //遍历未成交订单数组
            exchange.CancelOrder(orders[i].Id); //逐个取消未成交的订单
            Sleep(500); //延时0.5秒
        }
        return false; // 如果取消了未成交的单子就返回false
    }
    return true; //如果没有未成交的订单就返回true
}

Xử lý các hợp đồng duy nhất: isEven ())Trong việc xử lý giao dịch lợi nhuận, có một tình huống một chân xảy ra, đây là việc xử lý tất cả các vị trí một cách đơn giản.

// 处理持有单个合约
Data.prototype.isEven = function () {
    var positionData = this.positionData; // 获取持仓信息
    var type = null; // 转换持仓方向
    // 如果持仓数组长度余2不等于0或者持仓数组长度不等于2
    if (positionData.length % 2 != 0 || positionData.length != 2) {
        for (var i = 0; i < positionData.length; i++) { // 遍历持仓数组
            if (positionData[i].Type == 0) { // 如果是多单
                type = 10; // 设置下单参数
            } else if (positionData[i].Type == 1) { // 如果是空单
                type = -10; // 设置下单参数
            }
            // 平掉所有仓位
            this.trade(positionData[i].ContractType, type, positionData[i].Amount);
        }
    }
}

Chart vẽ:drawingChart ())Gọi phương pháp ObjChart.add () để vẽ các dữ liệu thị trường và các chỉ số cần thiết trên biểu đồ: tăng, giảm, tăng, giảm, chênh lệch giá dương / ngược.

// 画图
Data.prototype.drawingChart = function (boll) {
    var nowTime = new Date().getTime();
    ObjChart.add([0, [nowTime, boll.up]]);
    ObjChart.add([1, [nowTime, boll.middle]]);
    ObjChart.add([2, [nowTime, boll.down]]);
    ObjChart.add([3, [nowTime, this.basb]]);
    ObjChart.add([4, [nowTime, this.sabb]]);
    ObjChart.update(chart);
}

Bước 4: Thực hiện mã xử lý trước giao dịch bên trong hàm đầu vào main (), mã này chỉ chạy một lần sau khi chương trình khởi động.

• Thông tin không quan trọng trong bộ điều khiển bộ lọc SetErrorFilter ()
• Thiết lập các loại tiền kỹ thuật số để giao dịchexchange.IO ( )
• Biểu đồ được vẽ trước khi chương trình khởi động ObjChart.reset ()
• Thông tin thanh trạng thái trước khi chương trình khởi động LogProfitReset ()

//入口函数
function main() {
    // 过滤控制台中不是很重要的信息
    SetErrorFilter("429|GetRecords:|GetOrders:|GetDepth:|GetAccount|:Buy|Sell|timeout|Futures_OP");
    exchange.IO("currency", name + '_USDT'); //设置要交易的数字货币币种
    ObjChart.reset(); //程序启动前清空之前绘制的图表
    LogProfitReset(); //程序启动前清空之前的状态栏信息
}

Sau khi xác định quá trình xử lý trước giao dịch ở trên, bạn sẽ chuyển sang bước tiếp theo, vào chế độ tìm kiếm, thực hiện lặp lại hàm onTick (), và đặt thời gian ngủ trong khi tìm kiếm Sleep (), vì API của một số sàn giao dịch tiền kỹ thuật số đã cài đặt giới hạn truy cập trong một khoảng thời gian nhất định.

//入口函数
function main() {
    // 过滤控制台中不是很重要的信息
    SetErrorFilter("429|GetRecords:|GetOrders:|GetDepth:|GetAccount|:Buy|Sell|timeout|Futures_OP");
    exchange.IO("currency", name + '_USDT'); //设置要交易的数字货币币种
    ObjChart.reset(); //程序启动前清空之前绘制的图表
    LogProfitReset(); //程序启动前清空之前的状态栏信息
    while (true) { // 进入轮询模式
        onTick(); // 执行onTick函数
        Sleep(500); // 休眠0.5秒
    }
}

Thu thập và tính toán dữ liệuBước 1: Thu thập các đối tượng dữ liệu cơ bản, số dư tài khoản, dữ liệu chỉ số Boll để sử dụng cho logic giao dịch.

// 交易条件
function onTick() {
    var data = new Data(tradeTypeA, tradeTypeB); // 创建一个基础数据对象
    var accountStocks = data.accountData.Stocks; // 账户余额
    var boll = data.boll(dataLength, timeCycle); // 获取boll指标数据
    if (!boll) return; // 如果没有boll数据就返回
}

Đặt đơn và xử lý tiếp theoBước 1: Theo logic chiến lược trên, thực hiện giao dịch mua bán. Đầu tiên sẽ quyết định giá và điều kiện chỉ số có phù hợp hay không, sau đó quyết định điều kiện nắm giữ có phù hợp hay không, cuối cùng thực hiện trade ().

// 交易条件
function onTick() {
    var data = new Data(tradeTypeA, tradeTypeB); // 创建一个基础数据对象
    var accountStocks = data.accountData.Stocks; // 账户余额
    var boll = data.boll(dataLength, timeCycle); // 获取boll指标数据
    if (!boll) return; // 如果没有boll数据就返回
    // 价差说明
    // basb = (合约A卖一价 - 合约B买一价)
    // sabb = (合约A买一价 - 合约B卖一价)
    if (data.sabb > boll.middle && data.sabb < boll.up) { // 如果sabb高于中轨
        if (data.mp(tradeTypeA, 0)) { // 下单前检测合约A是否有多单
            data.trade(tradeTypeA, "closebuy"); // 合约A平多
        }
        if (data.mp(tradeTypeB, 1)) { // 下单前检测合约B是否有空单
            data.trade(tradeTypeB, "closesell"); // 合约B平空
        }
    } else if (data.basb < boll.middle && data.basb > boll.down) { // 如果basb低于中轨
        if (data.mp(tradeTypeA, 1)) { // 下单前检测合约A是否有空单
            data.trade(tradeTypeA, "closesell"); // 合约A平空
        }
        if (data.mp(tradeTypeB, 0)) { // 下单前检测合约B是否有多单
            data.trade(tradeTypeB, "closebuy"); // 合约B平多
        }
    }
    if (accountStocks * Math.max(data.askA, data.askB) > 1) { // 如果账户有余额
        if (data.basb < boll.down) { // 如果basb价差低于下轨
            if (!data.mp(tradeTypeA, 0)) { // 下单前检测合约A是否有多单
                data.trade(tradeTypeA, "buy"); // 合约A开多
            }
            if (!data.mp(tradeTypeB, 1)) { // 下单前检测合约B是否有空单
                data.trade(tradeTypeB, "sell"); // 合约B开空
            }
        } else if (data.sabb > boll.up) { // 如果sabb价差高于上轨
            if (!data.mp(tradeTypeA, 1)) { // 下单前检测合约A是否有空单
                data.trade(tradeTypeA, "sell"); // 合约A开空
            }
            if (!data.mp(tradeTypeB, 0)) { // 下单前检测合约B是否有多单
                data.trade(tradeTypeB, "buy"); // 合约B开多
            }
        }
    }
}

Bước 2: Sau khi hoàn thành đơn đặt hàng, cần xử lý các trường hợp bất thường như đơn đặt hàng chưa hoàn thành, giữ một hợp đồng và vẽ biểu đồ.

// 交易条件
function onTick() {
    var data = new Data(tradeTypeA, tradeTypeB); // 创建一个基础数据对象
    var accountStocks = data.accountData.Stocks; // 账户余额
    var boll = data.boll(dataLength, timeCycle); // 获取boll指标数据
    if (!boll) return; // 如果没有boll数据就返回
    // 价差说明
    // basb = (合约A卖一价 - 合约B买一价)
    // sabb = (合约A买一价 - 合约B卖一价)
    if (data.sabb > boll.middle && data.sabb < boll.up) { // 如果sabb高于中轨
        if (data.mp(tradeTypeA, 0)) { // 下单前检测合约A是否有多单
            data.trade(tradeTypeA, "closebuy"); // 合约A平多
        }
        if (data.mp(tradeTypeB, 1)) { // 下单前检测合约B是否有空单
            data.trade(tradeTypeB, "closesell"); // 合约B平空
        }
    } else if (data.basb < boll.middle && data.basb > boll.down) { // 如果basb低于中轨
        if (data.mp(tradeTypeA, 1)) { // 下单前检测合约A是否有空单
            data.trade(tradeTypeA, "closesell"); // 合约A平空
        }
        if (data.mp(tradeTypeB, 0)) { // 下单前检测合约B是否有多单
            data.trade(tradeTypeB, "closebuy"); // 合约B平多
        }
    }
    if (accountStocks * Math.max(data.askA, data.askB) > 1) { // 如果账户有余额
        if (data.basb < boll.down) { // 如果basb价差低于下轨
            if (!data.mp(tradeTypeA, 0)) { // 下单前检测合约A是否有多单
                data.trade(tradeTypeA, "buy"); // 合约A开多
            }
            if (!data.mp(tradeTypeB, 1)) { // 下单前检测合约B是否有空单
                data.trade(tradeTypeB, "sell"); // 合约B开空
            }
        } else if (data.sabb > boll.up) { // 如果sabb价差高于上轨
            if (!data.mp(tradeTypeA, 1)) { // 下单前检测合约A是否有空单
                data.trade(tradeTypeA, "sell"); // 合约A开空
            }
            if (!data.mp(tradeTypeB, 0)) { // 下单前检测合约B是否有多单
                data.trade(tradeTypeB, "buy"); // 合约B开多
            }
        }
    }
    data.cancelOrders(); // 撤单
    data.drawingChart(boll); // 画图
    data.isEven(); // 处理持有单个合约
}

Bước 6: Chiến lược hoàn chỉnh

Trên đây, chúng tôi đã tạo ra một chiến lược giao dịch lãi suất dài hạn đơn giản với hơn 200 dòng.

// 全局变量
// 声明一个配置图表的 chart 对象
var chart = {
    __isStock: true,
    tooltip: {
        xDateFormat: '%Y-%m-%d %H:%M:%S, %A'
    },
    title: {
        text: '交易盈亏曲线图（详细）'
    },
    rangeSelector: {
        buttons: [{
            type: 'hour',
            count: 1,
            text: '1h'
        }, {
            type: 'hour',
            count: 2,
            text: '3h'
        }, {
            type: 'hour',
            count: 8,
            text: '8h'
        }, {
            type: 'all',
            text: 'All'
        }],
        selected: 0,
        inputEnabled: false
    },
    xAxis: {
        type: 'datetime'
    },
    yAxis: {
        title: {
            text: '价差'
        },
        opposite: false,
    },
    series: [{
        name: "上轨",
        id: "线1,up",
        data: []
    }, {
        name: "中轨",
        id: "线2,middle",
        data: []
    }, {
        name: "下轨",
        id: "线3,down",
        data: []
    }, {
        name: "basb",
        id: "线4,basb",
        data: []
    }, {
        name: "sabb",
        id: "线5,sabb",
        data: []
    }]
};
var ObjChart = Chart(chart); // 画图对象
var bars = []; // 存储价差序列
var oldTime = 0; // 记录历史数据时间戳

// 参数
var tradeTypeA = "this_week"; // 套利A合约
var tradeTypeB = "quarter"; // 套利B合约
var dataLength = 10; //指标周期长度
var timeCycle = 1; // K线周期
var name = "ETC"; // 币种
var unit = 1; // 下单量

// 基础数据
function Data(tradeTypeA, tradeTypeB) { // 传入套利A合约和套利B合约
    this.accountData = _C(exchange.GetAccount); // 获取账户信息
    this.positionData = _C(exchange.GetPosition); // 获取持仓信息
    var recordsData = _C(exchange.GetRecords); //获取K线数据
    exchange.SetContractType(tradeTypeA); // 订阅套利A合约
    var depthDataA = _C(exchange.GetDepth); // 套利A合约深度数据
    exchange.SetContractType(tradeTypeB); // 订阅套利B合约
    var depthDataB = _C(exchange.GetDepth); // 套利B合约深度数据
    this.time = recordsData[recordsData.length - 1].Time; // 获取最新数据时间
    this.askA = depthDataA.Asks[0].Price; // 套利A合约卖一价
    this.bidA = depthDataA.Bids[0].Price; // 套利A合约买一价
    this.askB = depthDataB.Asks[0].Price; // 套利B合约卖一价
    this.bidB = depthDataB.Bids[0].Price; // 套利B合约买一价
    // 正套价差(合约A卖一价 - 合约B买一价)
    this.basb = depthDataA.Asks[0].Price - depthDataB.Bids[0].Price;
    // 反套价差(合约A买一价 - 合约B卖一价)
    this.sabb = depthDataA.Bids[0].Price - depthDataB.Asks[0].Price;
}

// 获取持仓
Data.prototype.mp = function (tradeType, type) {
    var positionData = this.positionData; // 获取持仓信息
    for (var i = 0; i < positionData.length; i++) {
        if (positionData[i].ContractType == tradeType) {
            if (positionData[i].Type == type) {
                if (positionData[i].Amount > 0) {
                    return positionData[i].Amount;
                }
            }
        }
    }
    return false;
}

// 合成新K线数据和boll指标数据
Data.prototype.boll = function (num, timeCycle) {
    var self = {}; // 临时对象
    // 正套价差和反套价差中间值
    self.Close = (this.basb + this.sabb) / 2;
    if (this.timeA == this.timeB) {
        self.Time = this.time;
    } // 对比两个深度数据时间戳
    if (this.time - oldTime > timeCycle * 60000) {
        bars.push(self);
        oldTime = this.time;
    } // 根据指定时间周期，在K线数组里面传入价差数据对象
    if (bars.length > num * 2) {
        bars.shift(); // 控制K线数组长度
    } else {
        return;
    }
    var boll = TA.BOLL(bars, num, 2); // 调用talib库中的boll指标
    return {
        up: boll[0][boll[0].length - 1], // boll指标上轨
        middle: boll[1][boll[1].length - 1], // boll指标中轨
        down: boll[2][boll[2].length - 1] // boll指标下轨
    } // 返回一个处理好的boll指标数据
}

// 下单
Data.prototype.trade = function (tradeType, type) {
    exchange.SetContractType(tradeType); // 下单前先重新订阅合约
    var askPrice, bidPrice;
    if (tradeType == tradeTypeA) { // 如果是A合约下单
        askPrice = this.askA; // 设置askPrice
        bidPrice = this.bidA; // 设置bidPrice
    } else if (tradeType == tradeTypeB) { // 如果是B合约下单
        askPrice = this.askB; // 设置askPrice
        bidPrice = this.bidB; // 设置bidPrice
    }
    switch (type) { // 匹配下单模式
        case "buy":
            exchange.SetDirection(type); // 设置下单模式
            return exchange.Buy(askPrice, unit);
        case "sell":
            exchange.SetDirection(type); // 设置下单模式
            return exchange.Sell(bidPrice, unit);
        case "closebuy":
            exchange.SetDirection(type); // 设置下单模式
            return exchange.Sell(bidPrice, unit);
        case "closesell":
            exchange.SetDirection(type); // 设置下单模式
            return exchange.Buy(askPrice, unit);
        default:
            return false;
    }
}

// 取消订单
Data.prototype.cancelOrders = function () {
    Sleep(500); // 撤单前先延时，因为有些交易所你懂的
    var orders = _C(exchange.GetOrders); // 获取未成交订单数组
    if (orders.length > 0) { // 如果有未成交的订单
        for (var i = 0; i < orders.length; i++) { //遍历未成交订单数组
            exchange.CancelOrder(orders[i].Id); //逐个取消未成交的订单
            Sleep(500); //延时0.5秒
        }
        return false; // 如果取消了未成交的单子就返回false
    }
    return true; //如果没有未成交的订单就返回true
}

// 处理持有单个合约
Data.prototype.isEven = function () {
    var positionData = this.positionData; // 获取持仓信息
    var type = null; // 转换持仓方向
    // 如果持仓数组长度余2不等于0或者持仓数组长度不等于2
    if (positionData.length % 2 != 0 || positionData.length != 2) {
        for (var i = 0; i < positionData.length; i++) { // 遍历持仓数组
            if (positionData[i].Type == 0) { // 如果是多单
                type = 10; // 设置下单参数
            } else if (positionData[i].Type == 1) { // 如果是空单
                type = -10; // 设置下单参数
            }
            // 平掉所有仓位
            this.trade(positionData[i].ContractType, type, positionData[i].Amount);
        }
    }
}

// 画图
Data.prototype.drawingChart = function (boll) {
    var nowTime = new Date().getTime();
    ObjChart.add([0, [nowTime, boll.up]]);
    ObjChart.add([1, [nowTime, boll.middle]]);
    ObjChart.add([2, [nowTime, boll.down]]);
    ObjChart.add([3, [nowTime, this.basb]]);
    ObjChart.add([4, [nowTime, this.sabb]]);
    ObjChart.update(chart);
}

// 交易条件
function onTick() {
    var data = new Data(tradeTypeA, tradeTypeB); // 创建一个基础数据对象
    var accountStocks = data.accountData.Stocks; // 账户余额
    var boll = data.boll(dataLength, timeCycle); // 获取boll指标数据
    if (!boll) return; // 如果没有boll数据就返回
    // 价差说明
    // basb = (合约A卖一价 - 合约B买一价)
    // sabb = (合约A买一价 - 合约B卖一价)
    if (data.sabb > boll.middle && data.sabb < boll.up) { // 如果sabb高于中轨
        if (data.mp(tradeTypeA, 0)) { // 下单前检测合约A是否有多单
            data.trade(tradeTypeA, "closebuy"); // 合约A平多
        }
        if (data.mp(tradeTypeB, 1)) { // 下单前检测合约B是否有空单
            data.trade(tradeTypeB, "closesell"); // 合约B平空
        }
    } else if (data.basb < boll.middle && data.basb > boll.down) { // 如果basb低于中轨
        if (data.mp(tradeTypeA, 1)) { // 下单前检测合约A是否有空单
            data.trade(tradeTypeA, "closesell"); // 合约A平空
        }
        if (data.mp(tradeTypeB, 0)) { // 下单前检测合约B是否有多单
            data.trade(tradeTypeB, "closebuy"); // 合约B平多
        }
    }
    if (accountStocks * Math.max(data.askA, data.askB) > 1) { // 如果账户有余额
        if (data.basb < boll.down) { // 如果basb价差低于下轨
            if (!data.mp(tradeTypeA, 0)) { // 下单前检测合约A是否有多单
                data.trade(tradeTypeA, "buy"); // 合约A开多
            }
            if (!data.mp(tradeTypeB, 1)) { // 下单前检测合约B是否有空单
                data.trade(tradeTypeB, "sell"); // 合约B开空
            }
        } else if (data.sabb > boll.up) { // 如果sabb价差高于上轨
            if (!data.mp(tradeTypeA, 1)) { // 下单前检测合约A是否有空单
                data.trade(tradeTypeA, "sell"); // 合约A开空
            }
            if (!data.mp(tradeTypeB, 0)) { // 下单前检测合约B是否有多单
                data.trade(tradeTypeB, "buy"); // 合约B开多
            }
        }
    }
    data.cancelOrders(); // 撤单
    data.drawingChart(boll); // 画图
    data.isEven(); // 处理持有单个合约
}

//入口函数
function main() {
    // 过滤控制台中不是很重要的信息
    SetErrorFilter("429|GetRecords:|GetOrders:|GetDepth:|GetAccount|:Buy|Sell|timeout|Futures_OP");
    exchange.IO("currency", name + '_USDT'); //设置要交易的数字货币币种
    ObjChart.reset(); //程序启动前清空之前绘制的图表
    LogProfitReset(); //程序启动前清空之前的状态栏信息
    while (true) { // 进入轮询模式
        onTick(); // 执行onTick函数
        Sleep(500); // 休眠0.5秒
    }
}

Địa chỉ chiến lược:https://www.fmz.com/strategy/104964

Bảy, tóm tắt

Chiến lược này chỉ là một câu đố, thực tế không đơn giản như vậy, nhưng bạn có thể chơi trí tưởng tượng của bạn theo ví dụ. Tôi cần nhắc nhở mọi người rằng theo kinh nghiệm hạn chế của tôi, trong tình hình thị trường tiền kỹ thuật số hiện tại, các chiến lược lợi nhuận thuần túy về thời gian gần như không đáng để chạy, cho dù là lợi nhuận ba góc không có rủi ro hoặc lợi nhuận xuyên thị trường.

Lý do là thị trường tương lai của bất kỳ sàn giao dịch tiền kỹ thuật số nào cũng không phải là tiền mã hóa. Hiện nay, hầu hết các loại tiền kỹ thuật số đều đã giảm khoảng 70% kể từ đầu năm nay. Điều đó có nghĩa là chiến lược luôn luôn là tiền mã hóa, nhưng giá tiền mã hóa đang giảm.