@tradalize/core
is a JavaScript library designed to facilitate algorithmic trading backtesting. The library provides a set of functions and classes allowing users to efficiently run backtests for their trading algorithms.
Install the package using npm:
npm install @tradalize/core
The main entry point in your future backrest is a Mainframe
class
import { Mainframe } from "@tradalize/core";
To run properly this class requires 2 parameters to be provided in its constructor - Datafeed
and Strategy
. These are essential concepts.
Datafeed
is a class, that will provide candlestick data to your Strategy
. You can implement your own Datafeed
(to provide data from your local DB or even from a file) or use some of the already implemented classes in this library (e.g. BinanceFuturesDatafeed
)
import { BinanceFuturesDatafeed } from "@tradalize/core";
To implement your custom Datafeed
you need to extend the abstract class and implement only 1 method and 2 properties
import { Datafeed } from "@tradalize/core";
class MyCustomDatafeed extends Datafeed {
// A symbol/ticker to load
symbol: string;
// A Timeframe wo work with (1d, 1h)
timeframe: Timeframe;
public async loadNextChunk(): Promise<Candle[]> {
// Here write your logic for loading new data
}
}
That's it. After that, this Datafeed
will emulate the market behavior and provide a new Candle
one by one to your strategy. When it reaches the end of the list, it will try to load a new chunk of data by calling the loadNextChunk
method. If this method returns an empty array, backtesting will stop. So you can control on which part of your data you want to run your backtests.
Before proceeding with Strategy
we have to discuss Broker
because they are tight together. During your backtests your strategy will execute orders. You can decide just to run your backtest in memory and see the result or save your trades to some persistent storage (DB, spreadsheet, whatever...) for further analysis. That is what Broker
is responsible for.
Same as all entities mentioned in this guide, you simply need to import and extend an abstract class, or you can use some predefined Brokers.
import { Broker } from "@tradalize/core";
class MyBroker extends Broker {
public openPosition(payload: OpenPositionPayload): void | Promise<void> {
// Implement your logic for the position opening here
// See the payload type in the type-hint
}
public closePosition(payload: ClosePositionPayload): void | Promise<void> {
// Implement your logic for position closing here
// See the payload type in the type-hint
}
}
Strategy
is the most valuable part of any backtest. Here you gone implement your logic of making trading decision.
import { Strategy, POSITION_DIRECTION } from "@tradalize/core";
class MyStrategy extends Strategy {
public update(candle: Candle): void | Promise<void> {
// update - is the only method you need to implement to make your strategy work
// this method will receive a new candle one by one until they ends
// Here's a sample strategy
const dayOfTheWeek = new Date(candle.openTime).getDay();
// Some trading condition
if (dayOfTheWeek === 0) {
// To open a trade you need to set this internal property to the position direction you need
// Trade will be executed on the next candle open
this.openOnNext = POSITION_DIRECTION.Long;
}
if (dayOfTheWeek === 5) {
// Same for the cancelation of the position, but here you just have to use the boolean value
this.closeOnNext = true;
}
}
}
And finally - let's run our strategy
import { Mainframe } from "@tradalize/core";
const broker = new MyBroker();
const strategy = new MyStrategy(broker);
const mf = new Mainframe(datafeed, strategy);
await mf.backtest();
That's it :)
This is only essential functionality. This guide does not cover how to work with analysis, analyze your trades, and strategy performance. It will be added soon.
As I said before - this is only a library. But I will add a starter app template soon to provide more "framework-ish" developer experience for the backtesting