Analisis Strategi Perdagangan Frekuensi Tinggi - Penny Jump

Perdagangan frekuensi tinggi adalah bidang yang menantang dan kompetitif yang bergantung pada eksekusi perdagangan yang cepat dan wawasan sensitif tentang mikrostruktur pasar. Salah satu strategi yang terkenal adalah Penny Jump, yang berfokus pada mengeksploitasi gajah di pasar untuk mendapatkan keuntungan kecil tetapi sering.

Memahami Strategi Penny Jump

Di pasar saham, gajah biasanya mengacu pada investor institusional yang ingin membeli atau menjual sejumlah besar saham tetapi tidak mau berdagang dengan harga pasar. Sebaliknya, mereka memilih untuk menggantung sejumlah besar pesanan batas di pasar, yaitu, pesanan yang tertunda, untuk menunjukkan niat mereka. Perilaku ini telah menarik perhatian luas di pasar, karena transaksi besar dapat berdampak signifikan pada pasar.

Sebagai contoh, misalkan kedalaman awal pasar saham adalah seperti ini: 200 ∙ $1.01 x $1.03 ∙ 200. Kemudian seekor gajah masuk dan menempatkan pesanan untuk membeli 3000 saham dengan harga $1.01 masing-masing. Pada titik ini, kedalaman pasar akan berubah menjadi 3.200 ∙ $1.01 x $1.03 ∙ 200. Tindakan ini seperti memperkenalkan seekor gajah, yang menjadi fokus peserta lain di pasar.

• Pasar yang kompetitif Untuk pedagang frekuensi tinggi, keuntungan mereka terutama berasal dari analisis mikrostruktur pasar untuk berspekulasi tentang niat pedagang lain. Setelah pemain besar muncul, pedagang frekuensi tinggi akan membangun posisi dengan cepat untuk menangkap fluktuasi harga kecil. Tujuan mereka adalah untuk berdagang sering dalam waktu singkat dan mengumpulkan keuntungan kecil tetapi kumulatif.

• Dilemma Gajah Meskipun gajah mungkin ingin beroperasi dalam skala besar di pasar, tindakan mereka juga mengungkapkan niat perdagangan mereka, menjadikannya target untuk pedagang frekuensi tinggi. Pedagang frekuensi tinggi mencoba untuk menetapkan posisi sebelumnya dan kemudian mendapatkan keuntungan dari fluktuasi harga. Kehadiran gajah di pasar dapat memicu reaksi di pasar yang kompetitif, sehingga mempengaruhi strategi perdagangan mereka.

• Kecurangan di Pasar Pada kenyataannya, investor institusional besar biasanya tidak menempatkan sejumlah besar pesanan beli atau jual di pasar secara terang-terangan, karena perilaku seperti itu dapat menyebabkan peserta lain di pasar untuk mengambil tindakan balas atau bahkan memanipulasi pasar.

Gagasan Inti dari Strategi Penny Jump

Gagasan inti dari strategi Penny Jump adalah bahwa setelah pemain besar muncul di pasar dan mendukung harga tertentu (seperti $ 1,01), pedagang frekuensi tinggi akan dengan cepat menaikkan penawaran mereka sebesar satu sen, misalnya, menjadi $ 1,02. Ini karena pedagang frekuensi tinggi memahami bahwa munculnya pemain besar berarti ada dukungan pembelian yang kuat pada tingkat harga ini, sehingga mereka mencoba mengikuti dengan cermat dengan harapan kenaikan harga. Ketika harga memang naik menjadi $ 1,03 x $ 1,05, pedagang frekuensi tinggi dapat menjual dengan cepat dan mendapatkan keuntungan sebesar $ 0,01.

Tidak hanya itu, tetapi pedagang frekuensi tinggi juga dapat menghasilkan keuntungan setelah membeli bahkan jika harga tidak naik, karena mereka tahu bahwa pemain besar telah mendukung harga dasar; oleh karena itu mereka dapat dengan cepat menjual saham mereka ke pemain besar ini dan mendapatkan keuntungan arbitrage kecil.

Menganalisis kode strategi Penny Jump

Kode sumber strategi:https://www.fmz.com/strategy/358

Kode strategi yang diberikan di atas adalah contoh, yang digunakan untuk menerapkan strategi Penny Jump. Di bawah ini adalah penjelasan rinci tentang kode, yang memungkinkan pemula untuk memahami bagaimana cara kerjanya:

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);
    }
}

Aku akan menganalisis kode strategi yang diberikan baris demi baris untuk membantu Anda memahami operasinya secara rinci.

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

Kode ini menginisialisasi objek bernama Counter, yang digunakan untuk melacak informasi statistik perdagangan strategi.

• i: Merupakan jumlah total transaksi.
• w: Menunjukkan jumlah transaksi yang berhasil.
• f: Menunjukkan jumlah transaksi yang gagal.

Atribut ini akan dicatat dan diperbarui selama proses pelaksanaan strategi.

var InitAccount = null;

Baris kode ini menginisialisasi variabel bernama InitAccount, yang akan menyimpan informasi akun ketika strategi mulai dijalankan.

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);
    }
}

Ini adalah fungsi bernamaCancelAll(), tujuannya adalah untuk membatalkan semua pesanan yang belum terpenuhi di pasar. Mari kita jelaskan fungsinya langkah demi langkah:

• while (true): Ini adalah loop tak terbatas, itu akan terus berjalan sampai tidak ada pesanan yang belum selesai.
• var orders = _C(exchange.GetOrders): Baris kode ini menggunakan fungsi exchange.GetOrders untuk mengambil semua pesanan yang sedang menunggu di rekening current dan menyimpannya di variabel order.
• if (orders.length == 0): Baris kode ini memeriksa untuk setiap pesanan yang belum selesai. Jika panjang array pesanan adalah 0, itu berarti tidak ada pesanan yang belum selesai dan loop akan terganggu (pecah).
• for (var i = 0; i < orders.length; i++): Ini adalah loop for yang berulang melalui semua perintah yang belum selesai.
• exchange.CancelOrder(orders[i].Id): Baris kode ini menggunakan fungsi exchange.CancelOrder() untuk membatalkan setiap pesanan dengan IDnya.
• Sleep(Interval): Baris kode ini memperkenalkan masa tunggu, berhenti untuk jangka waktu tertentu (dalam milidetik), untuk memastikan bahwa operasi pembatalan pesanan tidak terlalu sering.

Baris kode ini memperkenalkan masa tunggu, berhenti untuk jangka waktu tertentu (dalam milidetik), untuk memastikan bahwa operasi pembatalan pesanan tidak terlalu sering.

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

Ini adalah fungsi bernamaupdateStatus(msg), yang digunakan untuk memperbarui dan mencatat informasi status transaksi. Ini menerima parameter msg, yang biasanya berisi informasi tentang status pasar saat ini. Operasi spesifik fungsi ini meliputi:

MenggunakanLogStatus()fungsi untuk merekam informasi yang ditampilkan di bilah status selama pelaksanaan strategi. Peraturanmsgparameter yang berisi informasi tentang kondisi pasar saat ini. Stempel waktu saat ini (new Date()) dilampirkan untuk menampilkan informasi waktu. Tujuan dari fungsi ini adalah untuk merekam dan memperbarui informasi status transaksi untuk pemantauan dan analisis selama pelaksanaan strategi.

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);
    }
}

Ini adalah fungsi eksekusi utamamain()Mari kita jelaskan operasinya baris demi baris:

• if (DisableLog): Baris kode ini memeriksa apakah variabel DisableLog benar, dan jika demikian, itu akan menonaktifkan rekaman log. Ini untuk memastikan bahwa log yang tidak perlu tidak dicatat oleh strategi.

• CancelAll(): Panggil fungsi CancelAll( yang dijelaskan sebelumnya untuk memastikan bahwa tidak ada pesanan yang belum selesai.

• InitAccount = _C(exchange.GetAccount): Baris kode ini mengambil informasi akun saat ini dan menyimpannya dalam variabel InitAccount. Ini akan digunakan untuk merekam status akun ketika strategi mulai dijalankan.

• var i = 0;danvar locks = 0;: Inisialisasi dua variabel, i dan kunci, yang akan digunakan dalam logika strategi berikutnya.

• while (true): Ini adalah loop tak terbatas, terutama digunakan untuk eksekusi strategi terus menerus.

Selanjutnya, kita akan menjelaskan logika strategi utama dalamwhile (true)lingkaran baris demi baris.

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): Baris kode ini memungkinkan strategi untuk tidur untuk jangka waktu tertentu, untuk mengontrol frekuensi pelaksanaan strategi. Parameter Interval mendefinisikan interval tidur (dalam milidetik).

• var depth = _C(exchange.GetDepth): Dapatkan informasi kedalaman pasar saat ini, termasuk harga dan jumlah pesanan jual dan pesanan beli Informasi ini akan disimpan dalam variabel kedalaman.

• if (depth.Asks.length === 0 || depth.Bids.length === 0): Baris kode ini memeriksa informasi kedalaman pasar, memastikan bahwa baik pesanan jual dan pesanan beli ada. Jika salah satunya tidak ada, ini menunjukkan bahwa pasar mungkin tidak memiliki informasi perdagangan yang cukup, sehingga strategi akan terus menunggu.

• updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ", Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks): Baris kode ini memanggil fungsi updateStatus untuk memperbarui informasi status strategi.

    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;: Inisialisasi variabel askPrice, itu akan digunakan untuk menyimpan harga pesanan jual yang memenuhi kondisi.

• for (i = 0; i < depth.Asks.length; i++): Ini adalah loop for yang digunakan untuk melintasi informasi harga dan kuantitas pesanan jual pasar.

• if (depth.Asks[i].Amount >= Lot): Dalam loop, periksa apakah jumlah setiap order jual lebih besar atau sama dengan Lot yang ditentukan (penghitungan tangan). Jika demikian, simpan harga order jual itu di askPrice dan selesaikan loop.

• if (askPrice === 0): Jika tidak ada pesanan jual yang memenuhi kondisi yang ditemukan (askPrice masih 0), strategi akan terus menunggu dan melewatkan operasi berikutnya.

• var elephant = null;: Inisialisasi variabel gajah, itu akan digunakan untuk menyimpan informasi pesanan beli yang diidentifikasi sebagai 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;

Lanjutkan untuk menelusuri informasi harga dan kuantitas pesanan beli pasar, melewatkan pesanan beli pertama (Pendawaran[0]).

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): Periksa apakah kesenjangan antara harga penawaran saat ini dan askPrice lebih besar dari ElephantSpace. Jika demikian, ini menunjukkan bahwa itu cukup jauh dari elephant, dan strategi tidak akan lagi melanjutkan pencarian.

• if (depth.Bids[i].Amount >= ElephantAmount): Periksa apakah jumlah pesanan beli saat ini lebih besar atau sama dengan ElephantAmount. Jika demikian, simpan informasi pesanan beli dalam variabel elephant.

• if (!elephant): Jika elephant tidak ditemukan, kembalikan hitungan kunci ke 0 dan terus menunggu.

• locks++: Jika elephant ditemukan, tingkatkan jumlah kunci. Ini untuk memastikan bahwa strategi hanya dilaksanakan setelah mengkonfirmasi keberadaan elephant beberapa kali dalam jangka waktu tertentu.

• if (locks < LockCount): Periksa apakah jumlah waktu penguncian telah memenuhi persyaratan (LockCount). Jika tidak, terus menunggu.

    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)): Panggilan fungsi updateStatus untuk mencatat status strategi saat ini, termasuk posisi gigi dari elephant yang ditemukan dan informasi terkait.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): Gunakan fungsi exchange.Buy untuk membeli elephant yang ditemukan. Harga pembelian adalah elephant.Price + PennyTick, jumlah pembelian adalah Lot, dan jelaskan operasi pembelian sebagai Bids[ + i + ].

• var ts = new Date().getTime(): Dapatkan timestamp dari waktu saat ini untuk perhitungan interval waktu berikutnya.

• while (true): Masukkan loop tak terbatas baru, digunakan untuk menunggu eksekusi elephant buy order.

• Sleep(CheckInterval): Strategi tidur untuk sementara waktu untuk mengontrol frekuensi memeriksa status pesanan.

• var orders = _C(exchange.GetOrders): Dapatkan semua informasi pesanan dari rekening current.

• if (orders.length == 0): Periksa apakah ada pesanan yang belum selesai, jika tidak, putus lingkaran.

• (new Date().getTime() - ts) > WaitInterval: Menghitung interval waktu antara waktu saat ini dan ketika elephant dibeli. Jika melebihi WaitInterval, itu berarti bahwa waktu menunggu telah habis.

• for (var i = 0; i < orders.length; i++)Periksa semua pesanan yang belum selesai.

• exchange.CancelOrder(orders[i].Id): Gunakan fungsi exchange.CancelOrder untuk membatalkan setiap pesanan yang belum selesai.

    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): Mendapatkan informasi rekening current.

• var opAmount = _N(account.Stocks - InitAccount.Stocks): Hitung perubahan aset akun setelah membeli elephant. Jika perubahannya kurang dari 0,001, ini menunjukkan bahwa pembelian telah gagal, meningkatkan jumlah kegagalan dan melanjutkan ke loop berikutnya.

• updateStatus("Successful payment: " + opAmount + ", Start taking action..."): Catat informasi pembelian elephant yang berhasil, termasuk jumlah yang dibeli.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): Gunakan fungsi exchange.Sell untuk menjual elephant yang berhasil dibeli untuk mendapatkan keuntungan. Harga jual adalah elephant.Price + (PennyTick * ProfitTick).

Masukkan loop tak terbatas baru, digunakan untuk menunggu eksekusi pesanan jual.

• var depth = _C(exchange.GetDepth): Dapatkan informasi pasar yang mendalam.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): Periksa informasi kedalaman pasar, jika harga pasar telah turun ke level stop-loss, kemudian eksekusi operasi stop-loss.

• CancelAll(): Panggil fungsi CancelAll( untuk membatalkan semua pesanan yang belum selesai, untuk menghindari risiko posisi.

• if (opAmount < 0.001): Periksa jumlah pembelian lagi, jika kurang dari 0,001, itu menunjukkan bahwa pembelian telah gagal, keluar dari lingkaran.

• exchange.Sell(depth.Bids[0].Price, opAmount): Melakukan operasi stop loss, menjual aset yang tersisa dengan harga terendah pasar saat ini.

Akhirnya, perbarui jumlah transaksi yang berhasil dan gagal berdasarkan apakah transaksi itu berhasil atau tidak, dan catat keuntungan perdagangan.

Ini adalah penjelasan baris demi baris dari seluruh strategi. Ide inti dari strategi ini adalah untuk menemukan elephants (pesanan beli besar) di pasar, membeli dan menjual mereka untuk mendapatkan keuntungan kecil. Ini mencakup beberapa parameter penting, seperti Lot, interval upaya ulang kesalahan (Interval), ElephantAmount, ElephantSpace, dll, untuk menyesuaikan strategi.

Secara umum, strategi ini adalah strategi perdagangan frekuensi tinggi yang bertujuan untuk memanfaatkan informasi kedalaman pasar untuk mengidentifikasi pesanan beli besar dan melakukan transaksi beli dan jual dalam waktu singkat. Ini membutuhkan pemantauan terus-menerus pasar dan pelaksanaan operasi beli dan jual untuk dengan cepat mendapatkan keuntungan kecil. Namun, ini juga merupakan strategi berisiko tinggi, karena membutuhkan respons cepat terhadap fluktuasi pasar sambil mempertimbangkan manajemen risiko dan mekanisme stop-loss untuk menghindari kerugian yang signifikan.

Harap dicatat bahwa strategi ini didasarkan pada pasar dan platform perdagangan tertentu. Untuk pasar dan bursa yang berbeda, penyesuaian dan optimalisasi yang sesuai mungkin diperlukan. Dalam penerapan praktis, investor perlu dengan hati-hati menguji dan mengevaluasi kinerja strategi untuk memastikannya selaras dengan tujuan investasi dan toleransi risiko mereka.

Saat Anda terus menjalankan strategi, itu akan berulang kali melakukan operasi berikut:

1. Pertama, strategi akan memeriksa informasi mendalam pasar untuk memahami situasi saat ini dari pesanan jual dan pesanan beli.

2. Selanjutnya, strategi akan mencoba untuk menemukan pesanan jual yang memenuhi kriteria, khususnya pesanan jual dengan jumlah yang lebih besar dari atau sama dengan Lot.

3. Kemudian, strategi akan terus mencari gajah (jumlah besar pesanan beli). Ini akan melintasi pesanan beli pasar, melewatkan yang pertama (biasanya pesanan beli dengan harga tertinggi). Jika menemukan gajah yang memenuhi kriteria, itu akan mencatat informasi tentang gajah, dan meningkatkan kunci.

4. Jika jumlah elephant yang cukup ditemukan secara berturut-turut (dikendalikan oleh parameter LockCount), strategi selanjutnya akan melakukan operasi berikut:

• Panggil fungsi updateStatus untuk merekam peralatan dan informasi terkait dari elephant.
• Gunakan fungsi exchange.Buy untuk membeli elephant, dengan harga pembelian elephant.Price + PennyTick, dan jumlah Lot.
• Mulai loop tak terbatas baru untuk menunggu eksekusi order beli.
• Periksa status order, jika sudah selesai, keluar dari loop.
• Jika waktu tunggu melebihi interval yang ditetapkan (WaitInterval), batalkan semua pesanan yang belum selesai.
• Menghitung perubahan aset akun setelah pembelian berhasil. Jika perubahan kurang dari 0,001, ini menunjukkan bahwa pembelian gagal; meningkatkan jumlah kegagalan dan melanjutkan loop berikutnya.
• Catat informasi tentang pembelian gajah yang berhasil, termasuk jumlah yang dibeli.

5. Selanjutnya, strategi akan terus memasuki loop tak terbatas baru, menunggu pelaksanaan operasi jual.

• Dapatkan informasi mendalam pasar, periksa apakah harga pasar telah mencapai level stop-loss.
• Jika harga pasar telah mencapai atau turun di bawah level stop loss, operasi stop loss akan dilaksanakan, yaitu, aset yang tersisa akan dijual.
• Panggil fungsi CancelAll untuk membatalkan semua pesanan yang belum selesai, mengurangi risiko posisi.
• Periksa kembali perubahan aset akun setelah pembelian berhasil. Jika perubahannya kurang dari 0,001, ini menunjukkan bahwa pembelian telah gagal dan keluar dari loop.
• Akhirnya, catat apakah transaksi berhasil atau tidak, dan perbarui jumlah keberhasilan dan kegagalan berdasarkan hasil transaksi.

Seluruh strategi secara terus menerus melakukan operasi di atas untuk menangkap gajah sebanyak mungkin dan mendapatkan keuntungan kecil. Ini adalah strategi perdagangan frekuensi tinggi yang membutuhkan respons cepat terhadap perubahan pasar, sementara juga mempertimbangkan manajemen risiko dan mekanisme stop-loss untuk melindungi modal. Investor harus dengan hati-hati mempertimbangkan menggunakan strategi ini, terutama di pasar yang sangat fluktuatif.

Ringkasan

Strategi Penny Jump adalah contoh khas dalam perdagangan frekuensi tinggi, menunjukkan permainan halus dan persaingan di antara peserta pasar. Strategi ini sangat menonjol di pasar cryptocurrency karena fluktuasinya yang besar, di mana investor institusional dan pedagang frekuensi tinggi semuanya mengejar keuntungan cepat. Namun, ini juga membuat pasar penuh tantangan, yang membutuhkan adaptasi dan penyesuaian strategi yang konstan untuk mempertahankan keunggulan kompetitif.