Best Practices for Strategy Backtesting in Cryptocurrency Markets with DolphinDB

The backtesting system utilizes an event-driven design and provides a suite of event functions, including initialization function, daily callback, and snapshot data callback. You can implement custom strategy logic within the corresponding callback functions. This section demonstrates how each event function is implemented in this case.

1. Using the initialize function, you can set up your strategy's key metrics and variables. In this example, userParam is a funding rate table. For detailed configuration, refer to the next section on engine parameter settings.

   Line 5 context["lastlastFunding"] stores the previous funding rate, which serves as a condition for closing positions.

   def initialize(mutable context, userParam){	
       // Initialization
   	print("initialize")
   	context["fundingRate"] = userParam
   	context["lastlastFunding"] = dict(SYMBOL,ANY)
   }

2. In daily callback function beforeTrading, the trading date can be obtained via contextDict["tradeDate"], as shown in line 4. In this case, the current day's funding rate table is transformed into a nested dictionary d, which is then stored in the context for convenient access. A nested dictionary structure is used here, with the instrument symbol and settlement time as the keys.

   def beforeTrading(mutable context){
       // Daily callback
       // Get the current trading day
   	print ("beforeTrading: " + context["tradeDate"])
       // Retrieve current funding rates and store them as a dictionary
   	fundingRate = context["fundingRate"]
   	d = dict(STRING,ANY)
   	for (i in distinct(fundingRate.symbol))
   	{
   		temp = select * from fundingRate where symbol = i 
   			and date(settlementTime) = context["tradeDate"]
   		d[i] = dict(temp.settlementTime,temp.lastFundingRate, true)
   	}
   	context["dailyLastFundingPrice"] = d
   }

3. In the market data callback function onBar, the parameter msg contains the latest minute-level market data passed from the backtesting engine, while the parameter indicator contains the subscribed indicators. Since this case does not involve indicator subscriptions, indicator will not be discussed in detail. The following code demonstrates the logic for opening and closing positions:
   • Since the msg dictionary contains market data for multiple instruments, a for(i in msg.keys()) {} loop is used to iterate through each symbol.
   • For each instrument, line 11 extracts the current funding rate—i.e., the fundingRate of the previous funding rate table. Then it checks whether the funding rate and current positions meet the criteria for opening or closing positions, and submits orders accordingly.

   def onBar(mutable context, msg, indicator = NULL){
       //...
   	dailyFundingRate = context["dailyLastFundingPrice"]
   	// Iterate over multiple instruments
   	for(i in msg.keys()){
   		istockSymbol = msg[i]["symbol"]  
   		istock = split(istockSymbol,"_")[0]
   		source = msg[i]["symbolSource"]
   		closePrice = msg[i]["close"]
   		// Get the funding rate for the current symbol based on the corresponding time interval
   		if(second(context["tradeTime"]) >= 16:00:00){
   			fundingRateTime = temporalAdd(datetime(context["tradeDate"]),16,"h")}
   		if(second(context["tradeTime"])>= 08:00:00 and second(context["tradeTime"]) 
   		< 16:00:00){
   			fundingRateTime = temporalAdd(datetime(context["tradeDate"]),8,"h")}
   		if(second(context["tradeTime"]) < 08:00:00){
   			fundingRateTime = datetime(context["tradeDate"])}
   		lastFundingPrice = dailyFundingRate[istock][fundingRateTime]
   		// Check the current position status: includes both spot and futures
   		spotPos = Backtest::getPosition(context["engine"], istock+"_0", "spot")
   		futurePos = Backtest::getPosition(context["engine"],istock+"_2","futures")
     //...
   		}
   }

In this example, context["fundingRate"] is the funding rate passed during initialization. You need to extract the rate for the corresponding symbol at the given time. Use Backtest::getPosition to retrieve current spot and futures positions.

Open position conditions are based on funding rate and position size, and orders are placed via Backtest::submitOrder.

// If funding rate > 0.03%, short perpetual contract and buy equivalent spot (max order size: 0.1) 		
if(spotPos.longPosition[0] <= 0.1 and futurePos.shortPosition[0] < 0.1 
    and lastFundingPrice > 0.0003){
	// Spot position
	if(istockSymbol == istock+"_0"){					
		Backtest::submitOrder(context["engine"], (istockSymbol, source, 
			context["tradeTime"], 5, closePrice,lowerLimit, upperLimit, qty,1, 
			slippage, 1, expireTime ), "buyopen_spot", 0, "spot")	 	 
		}
	// Futures position
	if(istockSymbol == istock + "_2"){		
		Backtest::submitOrder(context["engine"], (istockSymbol, source, 
			context["tradeTime"], 5, closePrice,lowerLimit, upperLimit, qty, 2, 
			slippage, 1, expireTime ), "sellopen_contract", 0, "futures")		
		}
	}
context["lastlastFunding"][istock] = lastFundingPrice[0]
}

For closing positions, check if the previous funding rate (context["lastlastFunding"]) was positive and the current rate is negative, and whether the position size is greater than 0.01.

// Close positions when funding rate turns negative	   
 if(Pos_spot.longPosition[0] > 0.1  and Pos_futures.shortPosition[0] > 0.1 
    and context["lastlastFunding"][istock] >= 0 and lastFundingPrice < 0){
    // Close spot
    if(istockSymbol == istock+"_0"){
			Backtest::submitOrder(context["engine"], (istockSymbol, source, 
				context["tradeTime"], 5, closePrice,lowerLimit, upperLimit, qty,3, 
				slippage, 1,expireTime ), "sellclose_spot", 0, "spot")  
			        }
    // Close futures
    if(istockSymbol == istock+"_2"){
			Backtest::submitOrder(context["engine"], (istockSymbol, source, 
				context["tradeTime"], 5, closePrice,lowerLimit, upperLimit, qty, 4, 
				slippage, 1,expireTime ), "buyclose_contract", 0, "futures")
			        }
	   }

Note: In submitOrder, the parameters upperLimit, lowerLimit, slippage, qty, and expireTime refer to take-profit price, stop-loss price, slippage, order quantity, and order expiration time, respectively. You can customize these based on your strategy.

In addition to market-driven strategies, the backtesting engine also supports handling order status updates, trade execution events, end-of-day accounting, and other finalization logic.

The backtest engine allows configuration of parameters such as start and end dates, initial capital, market type, order delay, and funding rates for perpetual contracts. You can adjust these settings to simulate different market conditions and evaluate strategy performance.

In this example, the strategy is for cryptocurrency trading, so the strategyType parameter should be set to "cryptocurrency". This ensures the engine applies the correct rules and logic for digital asset markets.

Example code for initializing parameters:

startDate = 2024.01.01
endDate = 2024.01.15
config = dict(STRING, ANY) 
config["startDate"] = startDate  
config["endDate"] = endDate  
config["strategyGroup"] = "cryptocurrency"  // Strategy type: cryptocurrency
cash = dict(STRING, DOUBLE)  // Initial account capital
cash["spot"] = 1000000.
cash["futures"] = 1000000.
cash["option"] = 1000000.
config["cash"] = cash
config["dataType"] = 3     // Market data type: minute-level
// Funding rate: passed to the engine via userParam
config["fundingRate"] = select  symbol, settlementTime, decimal128(lastFundingRate,8)
 as lastFundingRate from CryptoFundingRate where  date(settlementTime) >= startDate 
 and date(settlementTime) <= endDate  order by settlementTime
userParam = table(1:0,[`symbol,`settlementTime,`lastFundingRate],[SYMBOL,TIMESTAMP,DECIMAL128(8)])
userParam = config["fundingRate"]

Note: The config["fundingRate"] parameter specifies the funding rate for cryptocurrency perpetual contracts. It can be passed into event functions using userParam. In this case, make sure to add userParam as an argument when defining and registering event functions, e.g., def initialize(mutable contextDict, userParam) or initialize{, userParam}.

When creating the backtestint engine, select event functions based on data frequency and strategy needs. In this case, only onBar is needed for minute-level data, and onSnapshot is skipped by leaving its position empty (using a comma placeholder).

// Create a backtest engine
strategyName = "Cryptocurrency"
try{Backtest::dropBacktestEngine(strategyName)}catch(ex){print ex}
engine = Backtest::createBacktestEngine(strategyName, config, securityReference, 
initialize{,userParam}, beforeTrading, onBar,, onOrder, onTrade,, finalize)
go

For cryptocurrency backtests, set the securityReference parameter based on contract info. Use SQL (e.g., update, select) to ensure the schema matches requirements in Section 1.1, or load a prepared table with loadText.

// Security reference table
securityReference = select last(contractType) as contractType 
from testData group by symbol 
update securityReference set optType = 1
update securityReference set strikePrice = decimal128(0, 8)
update securityReference set contractSize = decimal128(100.,8)
update securityReference set marginRatio = decimal128(0.2,8)
update securityReference set tradeUnit = decimal128(0.2,8)
update securityReference set priceUnit = decimal128(0.,8)
update securityReference set priceTick = decimal128(0.,8)
update securityReference set takerRate = decimal128(0.,8)
update securityReference set makerRate = decimal128(0.,8)
update securityReference set deliveryCommissionMode = iif(contractType!=2,1,2)    
update securityReference set fundingSettlementMode = iif(contractType==2,1,2)     
update securityReference set lastTradeTime = timestamp()   // Last settlement time

Once you’ve set up the engine, you can use the appendQuotationMsg method to append market data to the engine and execute the backtesting. The testData variable contains minute-level market data. Convert it if needed to match the required format (see Section 1.2).

// Market data: extracted and converted to match required structure and types
cryptoMinData = loadText("root/data/Crypto1minData.csv") 
testData = select symbol + "_" + string(contractType) as symbol,symbolSource,
tradeTime,tradingDay,decimal128(open,8) as open,decimal128(low,8) as low, 
decimal128(high,8)as high,decimal128(close,8)as close,decimal128(volume,8)as volume,
decimal128(amount,8) as amount, decimal128(upLimitPrice,8) as upLimitPrice,
decimal128(downLimitPrice,8) as downLimitPrice,signal,decimal128(prevClosePrice,8)as
prevClosePrice,decimal128(settlementPrice,8) as settlementPrice,
decimal128(prevSettlementPrice,8) as prevSettlementPrice,contractType 
from Crypto1minData  where  date(tradeTime) >= startDate and date(tradeTime) <= 
endDate order by tradeTime
//......
Backtest::appendQuotationMsg(engine,testData)

The Backtest plugin offers a list of methods to obtain the corresponding results, including:

• getPosition/getDailyPosition: Returns the position of a specific asset.
• getTradeDetails: Returns details about orders.
• getAvailableCash: Returns the account's available cash.
• getTodayPnl: Returns the profit and loss for the current day.
• getTotalPortfolios/getDailyTotalPortfolios: Returns the total equity of all portfolios.
• getReturnSummary: Returns a summary of returns.
• getContextDict: Returns the global variables.

For cryptocurrency strategies, some methods support specifying the account type (e.g., spot, futures, option). Below are examples of commonly used result queries. The field “direction” indicates order direction (1 means buy open).

// Retrieve trade details; returns all trades if accountType is not set
Backtest::getTradeDetails(engine, 'spot') 

Use Backtest::getDailyPosition to get daily positions by account type. The futures position data in this example is shown in Figure 2-2. Fields like “lastDayLongPosition”, “shortPosition”, and “shortPositionAvgPrice” represent the previous day's long position, current short position, and average short price, respectively.

// Retrieve daily positions; accountType can be specified
Backtest::getDailyPosition(engine, 'futures')    

Use Backtest::getReturnSummary to view the overall strategy performance. If accountType is specified, results are limited to that account; otherwise, returns cover all accounts. Figure 2-3 shows the return summary. Key fields include “totalReturn” and “annualReturn”.

// Return summary; specify accountType to filter, or omit to show all accounts
Backtest::getReturnSummary(engine)