Tài nguyên đang được tải lên... tải...
  1. Chất tiêu hóa
  2. Bản gốc
  3. Phân tích chiến lược giao dịch tần số cao - Penny Jump

Phân tích chiến lược giao dịch tần số cao - Penny Jump

Tác giả:FMZ~Lydia, Tạo: 2023-11-07 10:44:20, Cập nhật: 2024-01-01 12:19:43

img

Giao dịch tần số cao là một lĩnh vực đầy thách thức và cạnh tranh dựa trên việc thực hiện giao dịch nhanh chóng và những hiểu biết nhạy cảm về cấu trúc vi mô của thị trường. Một chiến lược đáng chú ý là Penny Jump, tập trung vào khai thác voi trên thị trường để đạt được lợi nhuận nhỏ nhưng thường xuyên.

Hiểu chiến lược nhảy xu

Trong thị trường chứng khoán, voi thường đề cập đến những nhà đầu tư tổ chức muốn mua hoặc bán một số lượng lớn cổ phiếu nhưng không sẵn sàng giao dịch theo giá thị trường. Thay vào đó, họ chọn treo một số lượng lớn các lệnh giới hạn trên thị trường, tức là các lệnh đang chờ, để chỉ ra ý định của họ. Hành vi này đã thu hút sự chú ý rộng rãi trên thị trường, bởi vì các giao dịch lớn có thể có tác động đáng kể đến thị trường.

Ví dụ, giả sử độ sâu ban đầu của thị trường chứng khoán như thế này: 200 ∙ $1.01 x $1.03 ∙ 200. Sau đó một con voi vào và đặt lệnh mua 3000 cổ phiếu với giá 1,01 mỗi cổ phiếu. Tại thời điểm này, độ sâu của thị trường sẽ thay đổi thành 3,200 ∙ $1.01 x $1.03 ∙ 200. Hành động này giống như giới thiệu một con voi, trở thành trọng tâm của những người tham gia khác trên thị trường.

  • Thị trường cạnh tranh Đối với các nhà giao dịch tần số cao, lợi nhuận của họ chủ yếu đến từ việc phân tích cấu trúc vi mô thị trường để suy đoán về ý định của các nhà giao dịch khác. Một khi một người chơi lớn xuất hiện, các nhà giao dịch tần số cao sẽ nhanh chóng thiết lập vị trí để nắm bắt các biến động giá nhỏ. Mục tiêu của họ là giao dịch thường xuyên trong một khoảng thời gian ngắn và tích lũy lợi nhuận nhỏ nhưng tích lũy.

  • Vấn đề của voi Mặc dù voi có thể muốn hoạt động trên quy mô lớn trên thị trường, nhưng hành động của chúng cũng tiết lộ ý định giao dịch của chúng, khiến chúng trở thành mục tiêu cho các nhà giao dịch tần số cao. Các nhà giao dịch tần số cao cố gắng thiết lập vị trí trước thời gian và sau đó kiếm lợi từ biến động giá. Sự hiện diện của voi trên thị trường có thể gây ra phản ứng trong các thị trường cạnh tranh, do đó ảnh hưởng đến chiến lược giao dịch của họ.

  • Sự lừa dối trên thị trường Trong thực tế, các nhà đầu tư tổ chức lớn thường không đặt một số lượng lớn các lệnh mua hoặc bán trên thị trường một cách trắng trợn, vì hành vi như vậy có thể khiến những người tham gia khác trên thị trường phải thực hiện các biện pháp đối phó hoặc thậm chí thao túng thị trường.

Ý tưởng cốt lõi của chiến lược nhảy Penny

Ý tưởng cốt lõi của chiến lược Penny Jump là một khi một "đầu thủ lớn" xuất hiện trên thị trường và hỗ trợ một mức giá cụ thể (chẳng hạn như $ 1,01), các nhà giao dịch tần số cao sẽ nhanh chóng tăng giá thầu của họ một xu, ví dụ, lên $ 1,02.

Không chỉ vậy, nhưng các nhà giao dịch tần số cao cũng có thể kiếm lợi nhuận sau khi mua ngay cả khi giá không tăng, bởi vì họ biết rằng người chơi lớn đã hỗ trợ giá cơ sở; do đó họ có thể nhanh chóng bán cổ phiếu của họ cho người chơi lớn này và kiếm được lợi nhuận trọng tài nhỏ.

Phân tích mã chiến lược Penny Jump

Mã nguồn chiến lược:https://www.fmz.com/strategy/358

Mã chiến lược được cung cấp ở trên là một ví dụ, được sử dụng để thực hiện chiến lược Penny Jump. Dưới đây là một lời giải thích chi tiết về mã, cho phép người mới bắt đầu hiểu cách nó hoạt động:

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

// Variables
var InitAccount = null;

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

function updateStatus(msg) {
    LogStatus("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", Counter.f, "\n"+msg+"#0000ff\n"+new Date());
}

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("Successful payment: " + opAmount +", Start taking action...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("Didn't get it, start to stop loss, currently buying one: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

Tôi sẽ phân tích mã chiến lược của bạn từng dòng để giúp bạn hiểu hoạt động chi tiết.

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

Mã này khởi tạo một đối tượng có tên là Counter, được sử dụng để theo dõi thông tin thống kê giao dịch của một chiến lược. Cụ thể, nó bao gồm ba thuộc tính:

  • i: đại diện cho tổng số giao dịch.
  • w: đại diện cho số lượng giao dịch thành công.
  • f: Tỷ lệ các giao dịch thất bại.

Các thuộc tính này sẽ được ghi lại và cập nhật trong quá trình thực hiện chiến lược.

var InitAccount = null;

Dòng mã này khởi tạo một biến có tên InitAccount, sẽ lưu trữ thông tin tài khoản khi chiến lược bắt đầu thực hiện.

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

Đây là một hàm tên làCancelAll(), mục đích của nó là hủy bỏ tất cả các đơn đặt hàng chưa hoàn thành trên thị trường.

  • while (true): Đây là một vòng lặp vô hạn, nó sẽ tiếp tục chạy cho đến khi không có lệnh chưa hoàn thành.
  • var orders = _C(exchange.GetOrders): Dòng mã này sử dụng chức năng exchange.GetOrders để lấy tất cả các lệnh đang chờ trong tài khoản vãng lai và lưu trữ chúng trong biến lệnh.
  • if (orders.length == 0): Dòng mã này kiểm tra bất kỳ đơn đặt hàng chưa hoàn thành nào. Nếu chiều dài của mảng đơn đặt hàng là 0, điều đó có nghĩa là không có đơn đặt hàng chưa hoàn thành và vòng lặp sẽ bị gián đoạn (phá vỡ).
  • for (var i = 0; i < orders.length; i++): Đây là một vòng lặp for lặp lại thông qua tất cả các lệnh chưa hoàn thành.
  • exchange.CancelOrder(orders[i].Id): Dòng mã này sử dụng hàm exchange.CancelOrder để hủy mỗi đơn đặt hàng bằng ID của nó.
  • Sleep(Interval): Dòng mã này giới thiệu thời gian chờ, tạm dừng trong một khoảng thời gian nhất định (trong milliseconds), để đảm bảo rằng hoạt động hủy lệnh không quá thường xuyên.

Dòng mã này giới thiệu thời gian chờ, tạm dừng trong một khoảng thời gian nhất định (trong milliseconds), để đảm bảo rằng hoạt động hủy lệnh không quá thường xuyên.

function updateStatus(msg) {
    LogStatus("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", Counter.f, "\n" + msg + "#0000ff\n" + new Date());
}

Đây là một hàm tên làupdateStatus(msg), được sử dụng để cập nhật và ghi lại thông tin trạng thái giao dịch. Nó chấp nhận một tham số msg, thường chứa thông tin về trạng thái thị trường hiện tại. Các hoạt động cụ thể của chức năng bao gồm:

Sử dụngLogStatus()chức năng để ghi lại thông tin được hiển thị trong thanh trạng thái trong quá trình thực thi chiến lược. Nó hiển thị văn bản về số lượng giao dịch, số lượng thành công và số lượng thất bại. Cácmsgtham số được đính kèm, chứa thông tin về tình trạng thị trường hiện tại. Thời gian hiện tại (new Date()) được đính kèm để hiển thị thông tin thời gian. Mục đích của chức năng này là ghi lại và cập nhật thông tin tình trạng giao dịch để theo dõi và phân tích trong quá trình thực hiện chiến lược.

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("Successful payment: " + opAmount +", Start taking action...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("Didn't get it, start to stop loss, currently buying one: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

Đây là chức năng thực hiện chínhmain()Chúng ta hãy giải thích các hoạt động của nó từng dòng:

  • if (DisableLog): Dòng mã này kiểm tra xem biến DisableLog có đúng hay không, và nếu đúng, nó sẽ vô hiệu hóa ghi nhật ký.

  • CancelAll(): Gọi chức năng CancelAll( được giải thích trước đây để đảm bảo không có đơn đặt hàng chưa hoàn thành.

  • InitAccount = _C(exchange.GetAccount): Dòng mã này lấy thông tin tài khoản hiện tại và lưu trữ nó trong biến InitAccount. Điều này sẽ được sử dụng để ghi lại trạng thái tài khoản khi chiến lược bắt đầu thực thi.

  • var i = 0;vàvar locks = 0;: Bắt đầu hai biến, i và khóa, mà sẽ được sử dụng trong logic chiến lược tiếp theo.

  • while (true): Đây là một vòng lặp vô hạn, chủ yếu được sử dụng để thực hiện liên tục các chiến lược.

Tiếp theo, chúng tôi sẽ giải thích logic chiến lược chính trongwhile (true)vòng lặp từng dòng.

while (true) {
    Sleep(Interval);
    var depth = _C(exchange.GetDepth);
    if (depth.Asks.length === 0 || depth.Bids.length === 0) {
        continue;
    }
    updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);

  • Sleep(Interval): Dòng mã này cho phép chiến lược ngủ trong một khoảng thời gian, để kiểm soát tần suất thực hiện chiến lược.

  • var depth = _C(exchange.GetDepth): Nhận thông tin sâu thị trường hiện tại, bao gồm cả giá và số lượng lệnh bán và mua.

  • if (depth.Asks.length === 0 || depth.Bids.length === 0): Dòng mã này kiểm tra thông tin chiều sâu thị trường, đảm bảo rằng cả hai lệnh bán và lệnh mua tồn tại. Nếu một trong hai lệnh không tồn tại, nó cho thấy thị trường có thể không có đủ thông tin giao dịch, vì vậy chiến lược sẽ tiếp tục chờ đợi.

  • updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ", Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks): Dòng mã này gọi hàm updateStatus để cập nhật thông tin trạng thái của chiến lược. Nó ghi lại trạng thái thị trường hiện tại, bao gồm giá thầu cao nhất, giá thầu thấp nhất và thời gian khóa trước đó (khóa).

    var askPrice = 0;
    for (i = 0; i < depth.Asks.length; i++) {
        if (depth.Asks[i].Amount >= Lot) {
            askPrice = depth.Asks[i].Price;
            break;
        }
    }
    if (askPrice === 0) {
        continue;
    }
    var elephant = null;

  • var askPrice = 0;: Bắt đầu biến askPrice, nó sẽ được sử dụng để lưu trữ giá của lệnh bán đáp ứng các điều kiện.

  • for (i = 0; i < depth.Asks.length; i++): Đây là một vòng lặp dùng để đi qua thông tin giá và số lượng của lệnh bán trên thị trường.

  • if (depth.Asks[i].Amount >= Lot): Trong vòng lặp, kiểm tra xem số lượng của mỗi lệnh bán lớn hơn hoặc bằng với lô được chỉ định (số tay). Nếu có, lưu trữ giá của lệnh bán đó trong askPrice và kết thúc vòng lặp.

  • if (askPrice === 0): Nếu không tìm thấy lệnh bán đáp ứng các điều kiện (askPrice vẫn là 0), chiến lược sẽ tiếp tục chờ và bỏ qua các hoạt động tiếp theo.

  • var elephant = null;: Bắt đầu biến elephant, nó sẽ được sử dụng để lưu trữ thông tin lệnh mua được xác định là elephant.

    for (i = 1; i < depth.Bids.length; i++) {
        if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
            break;
        }
        if (depth.Bids[i].Amount >= ElephantAmount) {
            elephant = depth.Bids[i];
            break;
        }
    }

    if (!elephant) {
        locks = 0;
        continue;
    }
    locks++;
    if (locks < LockCount) {
        continue;
    }
    locks = 0;

Tiếp tục đi qua thông tin giá và số lượng của lệnh mua thị trường, bỏ qua lệnh mua đầu tiên (Bids[0]).

  • if ((askPrice - depth.Bids[i].Price) > ElephantSpace): Kiểm tra xem khoảng cách giữa giá đặt thầu hiện tại và askPrice có lớn hơn ElephantSpace không. Nếu có, nó chỉ ra rằng nó đủ xa với elephant và chiến lược sẽ không còn tiếp tục tìm kiếm.

  • if (depth.Bids[i].Amount >= ElephantAmount): Kiểm tra xem số lượng của lệnh mua hiện tại có lớn hơn hoặc bằng với ElephantAmount không.

  • if (!elephant): Nếu không tìm thấy phùi, đặt lại số khóa thành 0 và tiếp tục chờ.

  • locks++: Nếu phùi được tìm thấy, tăng số lượng khóa. Điều này là để đảm bảo rằng chiến lược được thực hiện chỉ sau khi xác nhận sự tồn tại của phùi nhiều lần trong một khoảng thời gian.

  • if (locks < LockCount): Kiểm tra xem số lần khóa đã đáp ứng yêu cầu (LockCount).

    updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant));
    exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
    var ts = new Date().getTime();
    while (true) {
        Sleep(CheckInterval);
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        if ((new Date().getTime() - ts) > WaitInterval) {
            for (var i = 0; i < orders.length; i++) {
                exchange.CancelOrder(orders[i].Id);
            }
        }
    }

  • updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant)): Gọi chức năng updateStatus để ghi lại trạng thái hiện tại của chiến lược, bao gồm vị trí bánh răng của phù được tìm thấy và thông tin liên quan.

  • exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): Sử dụng chức năng exchange.Buy để mua con voi tìm thấy. Giá mua là con voi. Giá + PennyTick, số lượng mua là Lot, và mô tả hoạt động mua là Bids[ + i + ].

  • var ts = new Date().getTime(): Nhận dấu thời gian của thời gian hiện tại để tính toán các khoảng thời gian sau đó.

  • while (true): Nhập một vòng lặp vô hạn mới, được sử dụng để chờ đợi việc thực hiện các lệnh mua.

  • Sleep(CheckInterval): Chiến lược ngủ trong một thời gian để kiểm soát tần suất kiểm tra trạng thái lệnh.

  • var orders = _C(exchange.GetOrders): Nhận tất cả thông tin đơn đặt hàng của tài khoản vãng lai.

  • if (orders.length == 0): Kiểm tra xem có bất kỳ đơn đặt hàng chưa hoàn thành, nếu không, phá vỡ vòng lặp.

  • (new Date().getTime() - ts) > WaitInterval: Tính khoảng thời gian giữa thời gian hiện tại và khi nào phùi đã được mua. Nếu vượt quá WaitInterval, điều đó có nghĩa là thời gian chờ đã hết.

  • for (var i = 0; i < orders.length; i++)Hãy đi qua tất cả các đơn đặt hàng chưa hoàn thành.

  • exchange.CancelOrder(orders[i].Id): Sử dụng chức năng exchange.CancelOrder để hủy mỗi đơn đặt hàng chưa hoàn thành.

    var account = _C(exchange.GetAccount);
    var opAmount = _N(account.Stocks - InitAccount.Stocks);
    if (opAmount < 0.001) {
        Counter.f++;
        Counter.i++;
        continue;
    }
    updateStatus("Successful payment: " + opAmount + ", Start taking action...");
    exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
    var success = true;
    while (true) {
        var depth = _C(exchange.GetDepth);
        if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))) {
            success = false;
            updateStatus("Didn't get it, start to stop loss, currently buying one: " + depth.Bids[0].Price);
            CancelAll();
            account = _C(exchange.GetAccount);
            var opAmount = _N(account.Stocks - InitAccount.Stocks);
            if (opAmount < 0.001) {
                break;
            }
            exchange.Sell(depth.Bids[0].Price, opAmount);
        }
        var orders = _C(exchange.GetOrders);
        if (orders.length === 0) {
            break;
        }
        Sleep(CheckInterval);
    }
    if (success) {
        Counter.w++;
    } else {
        Counter.f++;
    }
    Counter.i++;
    var account = _C(exchange.GetAccount);
    LogProfit(account.Balance - InitAccount.Balance, account);
}

  • var account = _C(exchange.GetAccount): Nhận thông tin tài khoản hiện tại.

  • var opAmount = _N(account.Stocks - InitAccount.Stocks): Tính toán sự thay đổi trong tài sản tài khoản sau khi mua phù. Nếu sự thay đổi nhỏ hơn 0,001, nó chỉ ra rằng việc mua đã thất bại, tăng số lượng thất bại và tiếp tục với vòng lặp tiếp theo.

  • updateStatus("Successful payment: " + opAmount + ", Start taking action..."): Ghi lại thông tin mua thành công của phù , bao gồm số lượng mua.

  • exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): Sử dụng chức năng exchange.Sell để bán elephant đã mua thành công để kiếm lợi nhuận. Giá bán là elephant.Price + (PennyTick * ProfitTick).

Nhập một vòng lặp vô hạn mới, được sử dụng để chờ cho việc thực hiện lệnh bán.

  • var depth = _C(exchange.GetDepth): Nhận thông tin sâu về thị trường.

  • if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): Kiểm tra thông tin độ sâu thị trường, nếu giá thị trường đã giảm xuống mức dừng lỗ, sau đó thực hiện hoạt động dừng lỗ.

  • CancelAll(): Gọi chức năng CancelAll( để hủy tất cả các đơn đặt hàng chưa hoàn thành, để tránh rủi ro vị trí.

  • if (opAmount < 0.001): Kiểm tra số lượng mua lại, nếu nó nhỏ hơn 0,001, nó cho thấy rằng mua đã thất bại, thoát khỏi vòng lặp.

  • exchange.Sell(depth.Bids[0].Price, opAmount): Thực hiện một giao dịch dừng lỗ, bán các tài sản còn lại với giá thấp nhất của thị trường hiện tại.

Cuối cùng, cập nhật số lượng giao dịch thành công và thất bại dựa trên việc giao dịch có thành công hay không, và ghi lại lợi nhuận giao dịch.

Đây là một lời giải thích từng dòng về toàn bộ chiến lược. Ý tưởng cốt lõi của chiến lược này là tìm phong (các lệnh mua lớn) trên thị trường, mua và bán chúng để kiếm được lợi nhuận nhỏ. Nó bao gồm một số thông số quan trọng, chẳng hạn như Lot, khoảng thời gian thử lại lỗi (Interval), ElephantAmount, ElephantSpace, v.v., để điều chỉnh chiến lược.

Nói chung, chiến lược này là một chiến lược giao dịch tần số cao nhằm mục đích sử dụng thông tin sâu thị trường để xác định các lệnh mua lớn và thực hiện giao dịch mua và bán trong một thời gian ngắn. Nó cần theo dõi thị trường liên tục và thực hiện các hoạt động mua và bán để nhanh chóng đạt được lợi nhuận nhỏ. Tuy nhiên, nó cũng là một chiến lược rủi ro cao, vì nó đòi hỏi phản ứng nhanh chóng với biến động thị trường trong khi xem xét quản lý rủi ro và cơ chế dừng lỗ để tránh tổn thất đáng kể.

Xin lưu ý rằng chiến lược dựa trên các thị trường và nền tảng giao dịch cụ thể. Đối với các thị trường và sàn giao dịch khác nhau, có thể cần phải điều chỉnh và tối ưu hóa thích hợp. Trong ứng dụng thực tế, các nhà đầu tư cần kiểm tra và đánh giá cẩn thận hiệu suất của chiến lược để đảm bảo nó phù hợp với mục tiêu đầu tư và dung nạp rủi ro của họ.

Khi bạn tiếp tục thực hiện chiến lược, nó sẽ lặp đi lặp lại các hoạt động sau:

  1. Đầu tiên, chiến lược sẽ kiểm tra thông tin sâu về thị trường để hiểu tình hình hiện tại của các đơn đặt hàng bán và mua.

  2. Tiếp theo, chiến lược sẽ cố gắng tìm lệnh bán đáp ứng các tiêu chí, cụ thể là bán lệnh với số lượng lớn hơn hoặc bằng Lot.

  3. Sau đó, chiến lược sẽ tiếp tục tìm kiếm phùi (số lượng lớn lệnh mua). Nó sẽ đi qua các lệnh mua của thị trường, bỏ qua lệnh mua đầu tiên (thường là lệnh mua có giá cao nhất). Nếu nó tìm thấy một phùi đáp ứng các tiêu chí, nó sẽ ghi lại thông tin về phùi và tăng khóa.

  4. Nếu một số lượng đủ phù được tìm thấy liên tục (được kiểm soát bởi tham số LockCount), chiến lược sẽ thực hiện các hoạt động sau:

  • Gọi chức năng updateStatus để ghi lại các thiết bị và thông tin liên quan của phù.
  • Sử dụng chức năng exchange.Buy để mua một elephant, với giá mua của elephant.Price + PennyTick, và một số lượng Lot.
  • Bắt đầu một vòng lặp vô hạn mới để chờ cho việc thực hiện lệnh mua.
  • Kiểm tra trạng thái lệnh, nếu hoàn thành, hãy thoát khỏi vòng lặp.
  • Nếu thời gian chờ vượt quá khoảng thời gian đặt (WaitInterval), hủy tất cả các đơn đặt hàng chưa hoàn thành.
  • Tính toán thay đổi tài sản tài khoản sau khi mua thành công. Nếu thay đổi nhỏ hơn 0,001, nó cho thấy mua đã thất bại; tăng số lần thất bại và tiếp tục vòng lặp tiếp theo.
  • Ghi lại thông tin về việc mua thành công phùi, bao gồm số lượng mua.
  1. Tiếp theo, chiến lược sẽ tiếp tục đi vào một vòng lặp vô hạn mới, chờ đợi việc thực hiện các hoạt động bán.
  • Nhận thông tin sâu về thị trường, kiểm tra xem giá thị trường đã đạt đến mức dừng lỗ hay không.
  • Nếu giá thị trường đạt hoặc giảm xuống dưới mức dừng lỗ, một giao dịch dừng lỗ sẽ được thực hiện, nghĩa là các tài sản còn lại sẽ được bán.
  • Gọi chức năng CancelAll để hủy tất cả các đơn đặt hàng chưa hoàn thành, giảm rủi ro vị trí.
  • Kiểm tra lại sự thay đổi tài sản tài khoản sau khi mua thành công. Nếu thay đổi nhỏ hơn 0,001, nó cho thấy việc mua đã thất bại và thoát khỏi vòng lặp.
  • Cuối cùng, ghi lại liệu giao dịch có thành công hay không, và cập nhật số lần thành công và thất bại dựa trên kết quả giao dịch.

Toàn bộ chiến lược liên tục thực hiện các hoạt động trên để bắt càng nhiều "con voi" càng tốt và có được lợi nhuận nhỏ. Đây là một chiến lược giao dịch tần suất cao đòi hỏi phải phản ứng nhanh với những thay đổi trên thị trường, đồng thời cũng xem xét quản lý rủi ro và cơ chế dừng lỗ để bảo vệ vốn. Các nhà đầu tư nên xem xét cẩn thận việc sử dụng chiến lược này, đặc biệt là trong các thị trường biến động cao.

Tóm lại

Chiến lược Penny Jump là một ví dụ điển hình trong giao dịch tần số cao, thể hiện trò chơi tinh tế và cạnh tranh giữa những người tham gia thị trường. Chiến lược này đặc biệt nổi bật trong thị trường tiền điện tử do sự biến động lớn của nó, nơi các nhà đầu tư tổ chức và các nhà giao dịch tần số cao đều theo đuổi lợi nhuận nhanh chóng. Tuy nhiên, điều này cũng làm cho thị trường đầy thách thức, đòi hỏi phải thích nghi và điều chỉnh liên tục các chiến lược để duy trì lợi thế cạnh tranh.

Thêm nữa

2019 FMZ - Tất cả các quyền được bảo lưu