Forum. StockSharp

Measuring Risk and Return - An Introduction to Markowitz Theory

2024-03-21T03:04:52Z

Last week, when introducing [How to Measure Position Risk - An Introduction to the VaR Method](https://www.fmz.com/bbs-topic/10255), it was mentioned that the risk of a portfolio is not equal to the risks of individual assets and is related to their price correlation. Taking two assets as an example, if their positive correlation is very strong, meaning they rise and fall together, then diversifying investments will not reduce risk. If there's a strong negative correlation, diversified investments can reduce risk significantly. The natural question then arises: how do we maximize returns at a certain level of risk when investing in a portfolio? This leads us to Markowitz Theory, which we are going to introduce today.

The Modern Portfolio Theory (MPT), proposed by Harry Markowitz in 1952, is a mathematical framework for portfolio selection. It aims to maximize expected returns by choosing different combinations of risk assets while controlling risk. The core idea is that the prices of assets do not move completely in sync with each other (i.e., there is incomplete correlation between assets), and overall investment risk can be reduced through diversified asset allocation.

### The Key Concept of Markowitz Theory
1. **Expected Return Rate**: This is the return that investors expect to receive from holding assets or an investment portfolio, usually predicted based on historical return data.
https://stocksharp.com/file/149420
Where, https://stocksharp.com/file/149421 is the expected return of the portfolio, https://stocksharp.com/file/149422 is the weight of the i-th asset in the portfolio, https://stocksharp.com/file/149423 is the expected return of the i-th asset.

2. **Risk (Volatility or Standard Deviation)**: Used to measure the uncertainty of investment returns or the volatility of investments.
https://stocksharp.com/file/149424
Where, https://stocksharp.com/file/149425 represents the total risk of the portfolio, https://stocksharp.com/file/149426 is the covariance of asset i and asset j, which measures the price change relationship between these two assets.

3. **Covariance**: Measures the mutual relationship between price changes of two assets.
https://stocksharp.com/file/149427
Where, https://stocksharp.com/file/149428 is the correlation coefficient of asset i and asset j, https://stocksharp.com/file/149432 and https://stocksharp.com/file/149429 are respectively the standard deviations of asset i and asset j.

4. **Efficient Frontier**: In the risk-return coordinate system, the efficient frontier is the set of investment portfolios that can provide the maximum expected return at a given level of risk.
https://stocksharp.com/file/149430
The diagram above is an illustration of an efficient frontier, where each point represents a different weighted investment portfolio. The x-axis denotes volatility, which equates to the level of risk, while the y-axis signifies return rate. Clearly, our focus lies on the upper edge of the graph as it achieves the highest returns at equivalent levels of risk.

In quantitative trading and portfolio management, applying these principles requires statistical analysis of historical data and using mathematical models to estimate expected returns, standard deviations and covariances for various assets. Then optimization techniques are used to find the best asset weight allocation. This process often involves complex mathematical operations and extensive computer processing - this is why quantitative analysis has become so important in modern finance. Next, we will illustrate how to optimize with specific Python examples.

### Python Code Example for Finding the Optimal Combination Using Simulation Method
Calculating the Markowitz optimal portfolio is a multi-step process, involving several key steps, such as data preparation, portfolio simulation, and indicator calculation. Please refer to: https://plotly.com/pytho...portfolio-optimization/

1. **Obtain market data**:

Through the ```get_data``` function, obtain the historical price data of the selected digital currency. This is the necessary data for calculating returns and risks, which are used to build investment portfolios and calculate Sharpe ratios.

2. **Calculate Return Rate and Risk**:

The ```calculate_returns_risk``` function was used to compute the annualized returns and annualized risk (standard deviation) for each digital currency. This is done to quantify the historical performance of each asset for use in an optimal portfolio.

3. **Calculate Markowitz Optimal Portfolio**:

The ```calculate_optimal_portfolio``` function was used to simulate multiple investment portfolios. In each simulation, asset weights were randomly generated and then the expected return and risk of the portfolio were calculated based on these weights.
By randomly generating combinations with different weights, it is possible to explore multiple potential investment portfolios in order to find the optimal one. This is one of the core ideas of Markowitz's portfolio theory.

The purpose of the entire process is to find the investment portfolio that yields the best expected returns at a given level of risk. By simulating multiple possible combinations, investors can better understand the performance of different configurations and choose the combination that best suits their investment goals and risk tolerance. This method helps optimize investment decisions, making investments more effective.

```
import numpy as np
import pandas as pd
import requests
import matplotlib.pyplot as plt

# Obtain market data
def get_data(symbols):
data = []
for symbol in symbols:
url = 'https://api.binance.com/api/v3/klines?symbol=%s&interval=%s&limit=1000'%(symbol,'1d')
res = requests.get(url)
data.append([float(line[4]) for line in res.json()])
return data

def calculate_returns_risk(data):
returns = []
risks = []

for d in data:
daily_returns = np.diff(d) / d[:-1]
annualized_return = np.mean(daily_returns) * 365
annualized_volatility = np.std(daily_returns) * np.sqrt(365)

returns.append(annualized_return)
risks.append(annualized_volatility)

return np.array(returns), np.array(risks)

# Calculate Markowitz Optimal Portfolio
def calculate_optimal_portfolio(returns, risks):
n_assets = len(returns)
num_portfolios = 3000

results = np.zeros((4, num_portfolios), dtype=object)

for i in range(num_portfolios):
weights = np.random.random(n_assets)
weights /= np.sum(weights)

portfolio_return = np.sum(returns * weights)
portfolio_risk = np.sqrt(np.dot(weights.T, np.dot(np.cov(returns, rowvar=False), weights)))

results[0, i] = portfolio_return
results[1, i] = portfolio_risk
results[2, i] = portfolio_return / portfolio_risk
results[3, i] = list(weights) # Convert weights to a list

return results

symbols = ['BTCUSDT','ETHUSDT', 'BNBUSDT','LINKUSDT','BCHUSDT','LTCUSDT']
data = get_data(symbols)

returns, risks = calculate_returns_risk(data)
optimal_portfolios = calculate_optimal_portfolio(returns, risks)

max_sharpe_idx = np.argmax(optimal_portfolios[2])
optimal_return = optimal_portfolios[0, max_sharpe_idx]
optimal_risk = optimal_portfolios[1, max_sharpe_idx]
optimal_weights = optimal_portfolios[3, max_sharpe_idx]

# Output results
print("Optimal combination:")
for i in range(len(symbols)):
print(f"{symbols[i]} Weight: {optimal_weights[i]:.4f}")

print(f"Expected return rate: {optimal_return:.4f}")
print(f"Expected risk (standard deviation): {optimal_risk:.4f}")
print(f"Sharpe ratio: {optimal_return / optimal_risk:.4f}")

# Visualized investment portfolio
plt.figure(figsize=(10, 5))
plt.scatter(optimal_portfolios[1], optimal_portfolios[0], c=optimal_portfolios[2], marker='o', s=3)
plt.title('portfolio')
plt.xlabel('std')
plt.ylabel('return')
plt.colorbar(label='sharp')
plt.show()
```
Final output result:
Optimal combination:
Weight of BTCUSDT: 0.0721
Weight of ETHUSDT: 0.2704
Weight of BNBUSDT: 0.3646
Weight of LINKUSDT: 0.1892
Weight of BCHUSDT: 0.0829
Weight of LTCUSDT: 0.0209
Expected return rate: 0.4195
Expected risk (standard deviation): 0.1219
Sharpe ratio: 3.4403
https://stocksharp.com/file/149431
From: https://blog.mathquant.c...to-markowitz-theory.html

Cracking the Code: Exploring Order Book Balance in Centralized Exchanges

2024-03-21T01:10:21Z

Recently, I have summarized some key insights from papers studying limit order books. You will learn how to measure the imbalance of transaction volume in the order book and its predictive ability for price trends. This article explores methods of using order book data to model price changes.

### First, let's talk about the order book.
Exchange order book balance refers to the relative balance state between buy and sell orders in an exchange. The order book is a real-time record of all pending buy and sell orders on the market. This includes orders from buyers and sellers who are willing to trade at different prices.

Below are some key concepts related to exchange order book balance:

- Buyer and Seller Orders: Buyer orders in the order book represent investors willing to purchase assets at a specific price, while seller orders represent investors willing to sell assets at a specific price.

- Order Book Depth: Order book depth refers to the number of orders on both the buyer and seller sides. A greater depth indicates there are more buy and sell orders in the market, which may be more liquid.

- Transaction Price and Transaction Volume: The transaction price is the price of the most recent trade, while the transaction volume is the quantity of assets traded at that price. The transaction price and volume are determined by the competition between buyers and sellers in the order book.

- Order Book Imbalance: Order book imbalance refers to the discrepancy between the number of buy and sell orders or total transaction volume. This can be determined by examining the depth of the order book, if one side has significantly more orders than the other, there may be an order book imbalance.

- Market Depth Chart: The market depth chart graphically presents the depth and balance of the order book. Typically, the number of orders from buyers and sellers is displayed on the price level in a bar chart or other visual ways.

- Factors Affecting the Price: The balance of the order book directly affects market prices. If there are more buy orders, it may push up the price; on the contrary, if there are more sell orders, it may cause a drop in price.

- High-frequency Trading and Algorithmic Trading: Order book balance is crucial for high-frequency trading and algorithmic trading, as they rely on real-time order book data to make decisions, aiming to seize market opportunities quickly.

Understanding the balance of order books is important for investors, traders, and market analysts, because it provides useful information about market liquidity, potential price direction, and market trends.

### Imbalance in Trading Volume
A key idea when analyzing limit order books is to determine whether the overall market tends to buy or sell. This concept is known as imbalance in trading volume.

The imbalance in trading volume at time t is defined as:
https://stocksharp.com/file/149405
Where, https://stocksharp.com/file/149406 represents the transaction volume of the best buy order at time t, https://stocksharp.com/file/149407 represents the transaction volume of the best sell order at time t. We can interpret ρt close to 1 as strong buying pressure, and ρt close to -1 as strong selling pressure. This only considers the transaction volumes of orders placed at the best buy price and best sell price, that is, L1 order book.
https://stocksharp.com/file/149408
Imbalance in trading volume and price changes. The graph shows the imbalance of tiered trading volumes (x-axis) and the average value of future price movements, standardized by price difference (y-axis). The dataset is a quarter's order flow from a certain market. There seems to be a linear relationship between first-level order imbalance and future price changes. However, on average, future price changes are within the bid-ask spread.

The imbalance in trading volume ρt will be divided into the following three paragraphs:
https://stocksharp.com/file/149409
It was discovered that these segments can predict future price changes:
https://stocksharp.com/file/149410
Regarding the predictive ability of volume imbalance, an analysis was conducted on the tick-by-tick order book of a certain commodity from January 2014 to December 2014. For each arriving market order (MO), the volume imbalance was recorded and segmented according to the number of ticks in which the mid-price changed within the next 10 milliseconds. The chart shows the distribution and mid-price changes for each segment. We can see that positive price changes are more likely to occur before order books with greater buying pressure. Similarly, negative changes are more likely to occur before order books with greater selling pressure.

### Order Flow Imbalance

The imbalance of trading volume focuses on the total trading volume in the limit order book. One drawback is that some of this volume may come from old orders, which contain less relevant information. We can instead focus on the trading volume of recent orders. This concept is known as order flow imbalance. You can achieve this by tracking individual markets and limit orders (requires Level 3 data) or observing changes in the limit order book.

Since Level 3 data is expensive and usually only available to institutional traders, we will focus on changes in the limit order book.

We can calculate the order flow imbalance by looking at how much the trading volumes have moved at best bid price and best ask price. The change in trading volume at best bid price is:
https://stocksharp.com/file/149411
This is a function involving three scenarios. The first scenario is, if the best buying price is higher than the previous best buying price, then all transaction volumes are new transaction volumes.
https://stocksharp.com/file/149412
The second scenario is, if the best buying price is the same as the previous best buying price, then the new transaction volume is the difference between the current total transaction volume and the previous total transaction volume.
https://stocksharp.com/file/149413
The third scenario is, if the best buying price is lower than the previous best buying price, then all previous orders have been traded and are no longer in the order book.
https://stocksharp.com/file/149414
The calculation method for the change in transaction volume at the best selling price is similar:
https://stocksharp.com/file/149415
The net order flow imbalance (OFI) at time t is given by the following formula:
https://stocksharp.com/file/149416
This will be a positive value when there are more buy orders, and a negative value when there are more sell orders. It measures both the quantity and direction of the transaction volume. In the previous part, order imbalance only measured direction without measuring the quantity of transactions.

You can add these values to get the net order flow imbalance (OFI) over a period of time:
https://stocksharp.com/file/149418
Use regression models to test whether order flow imbalance contains information about future price changes:
https://stocksharp.com/file/149417
The calculated OFI value above focuses on the best buying price and selling price. In part 4, the values of the top 5 best prices were also calculated, providing 5 inputs instead of just one. They found that a deep study of the order book can provide new information for future price changes.

### Summary
Here, I have summarized some key insights from papers studying the order volume in limit order books. These papers indicate that the order book contains information highly predictive of future price changes. However, these changes cannot overcome the bid-ask spread.

I have added links to the papers in the references section. Please refer to them for more detailed information.

References & Notes

- Álvaro Cartea, Ryan Francis Donnelly, and Sebastian Jaimungal: "Enhancing Trading Strategies with Order Book Signals" Applied Mathematical Finance 25(1) pp. 1–35 (2018)
- Alexander Lipton, Umberto Pesavento, and Michael G Sotiropoulos: "Trade arrival dynamics and quote imbalance in a limit order book" arXiv (2013)
- Álvaro Cartea, Sebastian Jaimungal, and J. Penalva: "Algorithmic and high-frequency trading." Cambridge University Press
- Ke Xu, Martin D. Gould, and Sam D. Howison: "Multi-Level Order-Flow Imbalance in a Limit Order Book" arXiv (2019)

Reprinted from: Author ~ {Leigh Ford, Adrian}.

From: https://blog.mathquant.c...ntralized-exchanges.html

Decoding Trends: Exploring the Correlation Between Currency Fluctuations and Bitcoin Price Movements

2024-03-20T09:12:58Z

In previous articles, we discussed a common phenomenon in the digital currency market: most digital currencies, especially those that follow the price fluctuations of Bitcoin and Ethereum, often show a trend of rising and falling together. This phenomenon reveals their high correlation with mainstream currencies. However, the degree of correlation between different digital currencies also varies. So how does this difference in correlation affect the market performance of each currency? In this article, we will use the bull market in the second half of 2023 as an example to explore this issue.

### The Synchronous Origin of the Digital Currency Market
The digital currency market is known for its volatility and uncertainty. Bitcoin and Ethereum, as the two giants in the market, often play a leading role in price trends. Most small or emerging digital currencies, in order to maintain market competitiveness and trading activity, often keep a certain degree of price synchronization with these mainstream currencies, especially those coins made by project parties. This synchronicity reflects the psychological expectations and trading strategies of market participants, which are important considerations in designing quantitative trading strategies.

### Formula and Calculation Method of Correlation
In the field of quantitative trading, the measurement of correlation is achieved through statistical methods. The most commonly used measure is the Pearson correlation coefficient, which measures the degree of linear correlation between two variables. Here are some core concepts and calculation methods:

The range of the Pearson Correlation Coefficient (denoted as r) is from -1 to +1, where +1 indicates a perfect positive correlation, -1 indicates a perfect negative correlation, and 0 indicates no linear relationship. The formula for calculating this coefficient is as follows:
https://stocksharp.com/file/149366

Among them, https://stocksharp.com/file/149367 and https://stocksharp.com/file/149368 are the observed values of two random variables, https://stocksharp.com/file/149369 and https://stocksharp.com/file/149370 are the average values of these two random variables respectively. Using Python scientific computing related packages, it's easy to calculate correlation.

### Data Collection
This article has collected the 4h K-line data for the entire year of 2023 from Binance, selecting 144 currencies that were listed on January 1st. The specific code to download the data is as follows:

```
import requests
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

ticker = requests.get('https://fapi.binance.com/fapi/v1/ticker/24hr')
ticker = ticker.json()
sort_symbols = [k['symbol'][:-4] for k in sorted(ticker, key=lambda x :-float(x['quoteVolume'])) if k['symbol'][-4:] == 'USDT']

def GetKlines(symbol='BTCUSDT',start='2020-8-10',end='2023-8-10',period='1h',base='fapi',v = 'v1'):
Klines = []
start_time = int(time.mktime(datetime.strptime(start, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000
end_time = min(int(time.mktime(datetime.strptime(end, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000,time.time()*1000)
intervel_map = {'m':60*1000,'h':60*60*1000,'d':24*60*60*1000}
while start_time < end_time:
time.sleep(0.5)
mid_time = start_time+1000*int(period[:-1])*intervel_map[period[-1]]
url = 'https://'+base+'.binance.com/'+base+'/'+v+'/klines?symbol=%s&interval=%s&startTime=%s&endTime=%s&limit=1000'%(symbol,period,start_time,mid_time)
res = requests.get(url)
res_list = res.json()
if type(res_list) == list and len(res_list) > 0:
start_time = res_list[-1][0]+int(period[:-1])*intervel_map[period[-1]]
Klines += res_list
if type(res_list) == list and len(res_list) == 0:
start_time = start_time+1000*int(period[:-1])*intervel_map[period[-1]]
if mid_time >= end_time:
break
df = pd.DataFrame(Klines,columns=['time','open','high','low','close','amount','end_time','volume','count','buy_amount','buy_volume','null']).astype('float')
df.index = pd.to_datetime(df.time,unit='ms')
return df

start_date = '2023-01-01'
end_date = '2023-11-16'
period = '4h'
df_dict = {}

for symbol in sort_symbols:
print(symbol)
df_s = GetKlines(symbol=symbol+'USDT',start=start_date,end=end_date,period=period)
if not df_s.empty:
df_dict[symbol] = df_s

df_close = pd.DataFrame(index=pd.date_range(start=start_date, end=end_date, freq=period),columns=df_dict.keys())
for symbol in symbols:
df_s = df_dict[symbol]
df_close[symbol] = df_s.close
df_close = df_close.dropna(how='any',axis=1)
```
### Market Review
After normalizing the data first, we calculate the index of average price fluctuations. It can be seen that there are two market trends in 2023. One is a significant increase at the beginning of the year, and the other is a major rise starting from October. Currently, it's basically at a high point in terms of index.

```
df_norm = df_close/df_close.fillna(method='bfill').iloc[0] #Normalization
total_index = df_norm.mean(axis=1)
total_index.plot(figsize=(15,6),grid=True);
```
https://stocksharp.com/file/149362
### Correlation Analysis
Pandas comes with a built-in correlation calculation. The weakest correlation with BTC price is shown in the following figure. Most currencies have a positive correlation, meaning they follow the price of BTC. However, some currencies have a negative correlation, which is considered an anomaly in digital currency market trends.
https://stocksharp.com/file/149363
```
corr_symbols = df_norm.corrwith(df_norm.BTC).sort_values().index
```
### Correlation and Price Increase
Here, the currencies are loosely divided into two groups. The first group consists of 40 currencies most correlated with BTC price, and the second group includes those least related to BTC price. By subtracting the index of the second group from that of the first, it represents going long on the first group while shorting the second one. In this way, we can calculate a relationship between price fluctuations and BTC correlation. Here is how you do it along with results:

```
(df_norm[corr_symbols[-40:]].mean(axis=1)-df_norm[corr_symbols[:40]].mean(axis=1)).plot(figsize=(15,6),grid=True);
```
https://stocksharp.com/file/149364
The results show that the currencies with stronger correlation to BTC price have better increases, and shorting currencies with low correlation also played a good hedging role. The imprecision here is that future data was used when calculating the correlation. Below, we divide the data into two groups: one group calculates the correlation, and another calculates the return after hedging. The result is shown in the following figure, and the conclusion remains unchanged.

Bitcoin and Ethereum as market leaders often have a huge impact on overall market trends. When these cryptocurrencies rise in price, market sentiment usually becomes optimistic and many investors tend to follow this trend. Investors may see this as a signal of an overall market increase and start buying other currencies. Due to collective behavior of market participants, currencies highly correlated with mainstream ones might experience similar price increases. At such times, expectations about price trends can sometimes become self-fulfilling prophecies. On the contrary, currencies negatively correlated with Bitcoin are unique; their fundamentals may be deteriorating or they may no longer be within sight of mainstream investors - there could even exist Bitcoin's blood-sucking situation where markets abandon them chasing for those able to keep up with rising prices.

```
corr_symbols = (df_norm.iloc[:1500].corrwith(df_norm.BTC.iloc[:1500])-df_norm.iloc[:1500].corrwith(total_index[:1500])).sort_values().index
```
https://stocksharp.com/file/149365
### Summary
This article discusses the Pearson correlation coefficient, revealing the degree of correlation between different currencies. The article demonstrates how to obtain data to calculate the correlation between currencies and use this data to assess market trends. It reveals that synchronicity in price fluctuations in the digital currency market not only reflects market psychology and strategy, but can also be quantified and predicted through scientific methods. This is particularly important for designing quantitative trading strategies.

There are many areas where the ideas in this article can be expanded, such as calculating rolling correlations, separately calculating correlations during rises and falls, etc., which can yield a lot of useful information.

From: https://blog.mathquant.c...rencies-and-bitcoin.html

Unveiling the Price Dynamics: Analyzing Performance Post Listing on Perpetual Contracts

2024-03-20T05:37:02Z

Most people know that once Binance announces the listing of a new perpetual contract, the spot price of this cryptocurrency often rises immediately. This has led to some robots scraping announcements constantly to buy in at the first moment, not to mention so-called insider information where the currency price has already risen before the announcement is even made. But how do these contract cryptocurrencies perform after they start trading? Do they continue their upward trend or have a pullback? Let's analyze it today.

### Data Preparation
Download the 4h K-line data of Binance's perpetual contract for the year 2023. The specific download code is introduced in the previous article: https://www.fmz.com/bbs-topic/10286. The listing time does not necessarily coincide with the 4-hour mark, which is a bit imprecise. However, the price at the start of trading is often chaotic. Using fixed intervals can filter out the impact of market opening without delaying analysis. In the data dataframe, NaN represents no data; once the first piece of data appears, it means that this coin has been listed. Here we calculate every 4 hours after listing relative to the first price increase and form a new table. Those already listed from the beginning are filtered out. As of November 16, 2023, Binance has listed a total of 86 currencies, averaging more than one every three days - quite frequent indeed.

The following is the specific processing code, where only data within 150 days of going live has been extracted.

```
df = df_close/df_close.fillna(method='bfill').iloc[0]
price_changes = {}
for coin in df.columns[df.iloc[0].isna()]:
listing_time = df[coin].first_valid_index()
price_changes[coin] = df[coin][df.index>listing_time].values
changes_df = pd.DataFrame.from_dict(price_changes, orient='index').T
changes_df.index = changes_df.index/6
changes_df = changes_df[changes_df.index<150]
changes_df.mean(axis=1).plot(figsize=(15,6),grid=True);
```
### Result Analysis
The results are shown in the following graph, where the horizontal axis represents the number of days on the shelf and the vertical axis represents the average index. This result can be said to be unexpected but reasonable. Surprisingly, after new contracts are listed, they almost all fall, and the longer they are listed, the more they fall. At least within half a year there is no rebound. But it's also reasonable to think about it; so-called listing benefits have been realized before listing, and subsequent continuous declines are normal. If you open up a K-line chart to look at weekly lines, you can also find that many newly-listed contract currencies follow this pattern - opening at their peak.
https://stocksharp.com/file/149353
https://stocksharp.com/file/149354
### Exclude the Impact of the Index
The previous article has mentioned that digital currencies are greatly affected by simultaneous rises and falls. Does the overall index's decline affect their performance? Here, let's change the price changes to be relative to the index changes and look at the results again. From what we see on the graph, it still looks the same - a continuous decline. In fact, it has declined even more compared to the index.

```
total_index = df.mean(axis=1)
df = df.divide(total_index,axis=0)
```
https://stocksharp.com/file/149355
### Binance's Currency Listing
By analyzing the relationship between the number of currencies listed each week and the index, we can clearly see Binance's listing strategy: frequent listings during a bull market, few listings during a bear market. February and October of this year were peak periods for listings, coinciding with bull markets. During times when the market was falling quite badly, Binance hardly listed any new contracts. It is evident that Binance also wants to take advantage of high trading volumes in bull markets and active new contracts to earn more transaction fees. They don't want new contracts to fall too badly either, but unfortunately, they can't always control it.
https://stocksharp.com/file/149356
### Summary
This article analyzes the 4h K-line data of Binance's perpetual contracts for the year 2023, showing that newly listed contracts tend to decline over a long period. This may reflect the market's gradual cooling off from initial enthusiasm and return to rationality. If you design a strategy to short a certain amount of funds on the first day of trading, and close out after holding for some time, there is a high probability of making money. Of course, this also carries risks; past trends do not represent the future. But one thing is certain: there is no need to chase hot spot or go long on newly listed contract currencies.
From: https://blog.mathquant.c...perpetual-contracts.html

Unlocking Efficiency: Leveraging FMZ's Extended API for Streamlined Group Control in Quantitative Trading

2024-03-20T00:41:57Z

With the popularization and development of quantitative trading, investors often need to manage a large number of live accounts, which brings great challenges to trading decisions, monitoring and execution. In order to improve management efficiency and reduce operational difficulty, traders on FMZ can use FMZ's extended API for group control management. In this article, we will discuss the advantages of using FMZ's extended API in quantitative trading and how to achieve efficient group control management.

Many users have their own customer live accounts that need managing and maintaining. When there are many customer live accounts, a more convenient way is needed for managing them (as few as dozens or as many as hundreds). FMZ provides a powerful extended API; using this for group control management has become an ideal choice.

### Centralized Monitoring
Through FMZ's extended API, you can centrally monitor the trading activities and asset conditions of all live accounts. Whether it is checking the positions of each account, historical trading records, or real-time monitoring of the profit and loss status of accounts, all of them can be achieved.

```
// Global variable
var isLogMsg = true // Control whether the log is printed
var isDebug = false // Debug mode
var arrIndexDesc = ["all", "running", "stop"]
var descRobotStatusCode = ["In idle", "Running", "Stopping", "Exited", "Stopped", "Strategy error"]
var dicRobotStatusCode = {
"all" : -1,
"running" : 1,
"stop" : 4,
}

// Extended log function
function LogControl(...args) {
if (isLogMsg) {
Log(...args)
}
}

// FMZ extended API call function
function callFmzExtAPI(accessKey, secretKey, funcName, ...args) {
var params = {
"version" : "1.0",
"access_key" : accessKey,
"method" : funcName,
"args" : JSON.stringify(args),
"nonce" : Math.floor(new Date().getTime())
}

var data = `${params["version"]}|${params["method"]}|${params["args"]}|${params["nonce"]}|${secretKey}`
params["sign"] = Encode("md5", "string", "hex", data)

var arrPairs = []
for (var k in params) {
var pair = `${k}=${params[k]}`
arrPairs.push(pair)
}
var query = arrPairs.join("&")

var ret = null
try {
LogControl("url:", baseAPI + "/api/v1?" + query)
ret = JSON.parse(HttpQuery(baseAPI + "/api/v1?" + query))
if (isDebug) {
LogControl("Debug:", ret)
}
} catch(e) {
LogControl("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}
Sleep(100) // Control frequency
return ret
}

// Obtain all live trading information of the specified strategy Id.
function getAllRobotByIdAndStatus(accessKey, secretKey, strategyId, robotStatusCode, maxRetry) {
var retryCounter = 0
var length = 100
var offset = 0
var arr = []

if (typeof(maxRetry) == "undefined") {
maxRetry = 10
}

while (true) {
if (retryCounter > maxRetry) {
LogControl("Exceeded the maximum number of retries", maxRetry)
return null
}
var ret = callFmzExtAPI(accessKey, secretKey, "GetRobotList", offset, length, robotStatusCode)
if (!ret || ret["code"] != 0) {
Sleep(1000)
retryCounter++
continue
}

var robots = ret["data"]["result"]["robots"]
for (var i in robots) {
if (robots[i].strategy_id != strategyId) {
continue
}
arr.push(robots[i])
}

if (robots.length < length) {
break
}
offset += length
}

return arr
}

function main() {
var robotStatusCode = dicRobotStatusCode[arrIndexDesc[robotStatus]]
var robotList = getAllRobotByIdAndStatus(accessKey, secretKey, strategyId, robotStatusCode)
if (!robotList) {
Log("Failed to obtain live trading data")
}

var robotTbl = {"type": "table", "title": "live trading list", "cols": [], "rows": []}
robotTbl.cols = ["live trading Id", "live trading name", "live trading status", "strategy name", "live trading profit"]

_.each(robotList, function(robotInfo) {
robotTbl.rows.push([robotInfo.id, robotInfo.name, descRobotStatusCode[robotInfo.status], robotInfo.strategy_name, robotInfo.profit])
})

LogStatus(_D(), "`" + JSON.stringify(robotTbl) + "`")
}
```
Strategy parameter design:
https://stocksharp.com/file/149332
Running on live trading:
https://stocksharp.com/file/149333
### One-click Execution
Group control management makes it very convenient to execute transactions with one-click. You can buy, sell, and close positions on multiple live trading accounts simultaneously without having to open each account individually. This not only improves execution efficiency, but also reduces the possibility of operational errors.

After obtaining the list of live trading accounts, we can send commands to these accounts and perform a series of predetermined operations. For example: clearing positions in the live account, pausing protection in the live account, switching modes in the live account. All these can be achieved through FMZ's extended API ```CommandRobot```.

As we continue writing code, we just need to add some interactions and calls to the extended API interface ```CommandRobot``` in our main function:

```
function main() {
var robotStatusCode = dicRobotStatusCode[arrIndexDesc[robotStatus]]
var robotList = getAllRobotByIdAndStatus(accessKey, secretKey, strategyId, robotStatusCode)
if (!robotList) {
Log("Failed to obtain live trading data")
}

var robotTbl = {"type": "table", "title": "live trading list", "cols": [], "rows": []}
robotTbl.cols = ["live trading Id", "live trading name", "live trading status", "strategy name", "live trading profit"]

_.each(robotList, function(robotInfo) {
robotTbl.rows.push([robotInfo.id, robotInfo.name, descRobotStatusCode[robotInfo.status], robotInfo.strategy_name, robotInfo.profit])
})

LogStatus(_D(), "`" + JSON.stringify(robotTbl) + "`")

while(true) {
LogStatus(_D(), ", Waiting to receive interactive commands", "\n", "`" + JSON.stringify(robotTbl) + "`")

var cmd = GetCommand()
if (cmd) {
var arrCmd = cmd.split(":")
if (arrCmd.length == 1 && cmd == "coverAll") {
_.each(robotList, function(robotInfo) {
var strCmd = "Clearance" // You can define the required message format
if (robotInfo.status != 1) { // Only the "live" trading platform can receive commands.
return
}
var ret = callFmzExtAPI(accessKey, secretKey, "CommandRobot", parseInt(robotInfo.id), strCmd)
LogControl("Send command to the live trading board with id: ", robotInfo.id, ":", strCmd, ", execution result:", ret)
})
}
}
Sleep(1000)
}
}
```
https://stocksharp.com/file/149334
The group control strategy sent instructions to "Test 1 A" and "Test 1 B".

### Strategy Synchronization
With FMZ's extended API, you can easily implement batch modifications of strategy parameters, and batch start or stop live trading.
https://stocksharp.com/file/149335
https://stocksharp.com/file/149336
https://stocksharp.com/file/149337
https://stocksharp.com/file/149338
### Summary
In quantitative trading, by using FMZ's extended API for group control management, traders can monitor, execute and adjust multiple live accounts more efficiently. This centralized management method not only improves operational efficiency, but also helps to better implement risk control and strategy synchronization.

For traders managing a large number of live accounts, FMZ's extended API provides them with a powerful and flexible tool that makes quantitative trading more convenient and controllable.

From: https://blog.mathquant.c...uantitative-trading.html

Unraveling the Mystery of Probability: Exploring Bayesian Decision Making and Mathematical Wisdom

2024-03-19T09:11:08Z

Bayesian statistics is a powerful discipline in the field of mathematics, with wide applications in many areas including finance, medical research, and information technology. It allows us to combine prior beliefs with evidence to derive new posterior beliefs, enabling us to make wiser decisions.

In this article, we will briefly introduce some of the main mathematicians who founded this field.

Before Bayes
To better understand Bayesian statistics, we need to go back to the 18th century and refer to mathematician De Moivre and his paper "The Doctrine of Chances".

In his paper, De Moivre solved many problems related to probability and gambling in his era. As you may know, his solution to one of these problems led to the origin of the normal distribution, but that's another story.

One of the simplest questions in his paper was:

"What is the probability of getting three heads when flipping a fair coin three times consecutively?"

Reading through the problems described in "The Doctrine of Chances", you might notice that most start with an assumption from which they calculate probabilities for given events. For example, in the above question there is an assumption that considers the coin as fair; therefore, obtaining a head during a toss has a probability of 0.5.

This would be expressed today in mathematical terms as:

Formula
```
𝑃(𝑋|𝜃)
```
However, what if we don't know whether the coin is fair? What if we don't know ```𝜃``` ?

### Thomas Bayes and Richard Price
Nearly fifty years later, in 1763, a paper titled "A Solution to the Problems in the Doctrine of Chances" was published in the Philosophical Transactions of the Royal Society of London.

In the first few pages of this document, there is a piece written by mathematician Richard Price that summarizes a paper his friend Thomas Bayes wrote several years before his death. In his introduction, Price explained some important discoveries made by Thomas Bayes that were not mentioned in De Moivre's "Doctrine of Chances".

In fact, he referred to one specific problem:

"Given an unknown event's number of successes and failures, find its chance between any two named degrees."

In other words, after observing an event we determine what is the probability that an unknown parameter ```θ``` falls between two degrees. This is actually one of the first problems related to statistical inference in history and it gave rise to term inverse probability. In mathematical terms:

Formula
```
𝑃( 𝜃 | 𝑋）
```
This is of course what we call the posterior distribution of Bayes' theorem today.

### For the Reason of No Cause and Effect
Understanding the motivations behind the research of these two elder ministers, **Thomas Bayes** and **Richard Price**, is actually quite interesting. But to do this, we need to temporarily put aside some knowledge about statistics.

We are in the 18th century when probability is becoming an increasingly interesting field for mathematicians. Mathematicians like de Moivre or Bernoulli have already shown that some events occur with a certain degree of randomness but are still governed by fixed rules. For example, if you roll a dice multiple times, one-sixth of the time it will land on six. It's as if there's a hidden rule determining fate's chances.

Now imagine being a mathematician and devout believer living during this period. You might be interested in understanding the relationship between this hidden rule and God.

This was indeed the question asked by Bayes and Price themselves. They hoped that their solution would directly apply to proving "the world must be the result of wisdom and intelligence; therefore providing evidence for God's existence as ultimate cause" - that is, cause without causality.

### Laplace
Surprisingly, around two years later in 1774, without having read Thomas Bayes' paper, the French mathematician Laplace wrote a paper titled "On the Causes of Events by Probability of Events", which is about inverse probability problems. On the first page, you can read the main principle:

"If an event can be caused by n different reasons, then the ratios between these causes' probabilities given the event are equal to the probabilities of events given these causes; and each cause's existence probability equals to the probability of causes given this event divided by total probabilities of events given each one of these causes."

This is what we know today as Bayes' theorem:
https://stocksharp.com/file/149324
Where ```P(θ)``` is a uniform distribution.

### Coin Experiment
We will bring Bayesian statistics to the present by using Python and PyMC library, and conduct a simple experiment.

Suppose a friend gives you a coin and asks if you think it's a fair coin. Because he is in a hurry, he tells you that you can only toss the coin 10 times. As you can see, there is an unknown parameter ```p``` in this problem, which is the probability of getting heads in tossing coins, and we want to estimate the most likely value of the ```p```.

(Note: We are not saying that parameter ```p``` is a random variable but rather that this parameter is fixed; we want to know where it's most likely between.)

To have different views on this problem, we will solve it under two different prior beliefs:

- 1. You have no prior information about the fairness of the coin, so you assign an equal probability to ```p```. In this case, we will use what is called a non-informative prior because you haven't added any information to your beliefs.

- 2. From your experience, you know that even if a coin might be unfair, it's hard to make it extremely unfair. Therefore, you believe the parameter ```p``` is unlikely to be less than 0.3 or more than 0.7. In this case, we will use an informative prior.

For these two scenarios, our prior beliefs will be as follows:
https://stocksharp.com/file/149325
After flipping a coin 10 times, you got heads twice. With this evidence, where are we likely to find our parameter ```p```?
https://stocksharp.com/file/149326
As you can see, in the first case, our prior distribution of parameter ```p``` is concentrated at the maximum likelihood estimate (MLE) ```p=0.2```, which is a method similar to that used by the frequency school. The true unknown parameter will be within the 95% confidence interval, between 0.04 and 0.48.

On the other hand, in cases where there is high confidence that parameter ```p``` should be between 0.3 and 0.7, we can see that the posterior distribution is around 0.4, much higher than what our MLE gives us. In this case, the true unknown parameter will be within a 95% confidence interval between 0.23 and 0.57.

Therefore, in the first case scenario you would tell your friend with certainty that this coin isn't fair but in another situation you'd say it's uncertain whether or not it's fair.

As you can see even when faced with identical evidence (two heads out of ten tosses), under different prior beliefs results may vary greatly; one advantage of Bayesian statistics over traditional methods lies here: like scientific methodology it allows us to update our beliefs by combining them with new observations and evidence.

### END
In today's article, we saw the origins of Bayesian statistics and its main contributors. Subsequently, there have been many other important contributors to this field of statistics (Jeffreys, Cox, Shannon and so on), reprinted from quantdare.com.

From: https://blog.mathquant.c...ind-decision-making.html

Which is More Suitable for Bottom Fishing, Low Market Value or Low Price?

2024-03-19T05:15:22Z

The previous articles https://www.fmz.com/digest-topic/10286 and https://www.fmz.com/digest-topic/10292 discussed the correlation between cryptocurrency price fluctuations and Bitcoin, as well as the impact of launching perpetual contracts on prices. This article will continue to explore another important factor affecting coin prices - market value. Readers familiar with quantitative trading should know that there is a most effective factor in the A-share market - small market value. The performance of small-cap stock rotation is very counter-intuitive, far exceeding various indicators, those interested can find out for themselves. So how does the price performance of small-cap or low-priced digital currencies look?

### Data Processing and Collection
This section uses the same data as the previous few articles, so it won't be repeated here.

### Performance of Low-Priced Currencies
Low-priced currencies usually refer to digital currencies with lower unit prices. These currencies are more attractive to small investors due to their low prices. Most people only see many zeros in the price but don't care much about the market value. Each unit reduction (zero) means that the price is multiplied by 10, which is very attractive to some people, but it may also be accompanied by higher price volatility and risk.

As usual, let's first look at the performance of the index, with two bull markets at the beginning and end of the year. Every week we select the 20 lowest priced currencies, and the results are very close to those of indicators, indicating that low prices do not provide too much additional return.

```
h = 1
lower_index = 1
lower_index_list = [1]
lower_symbols = df_close.iloc[0].dropna().sort_values()[:20].index
lower_prices = df_close.iloc[0][lower_symbols]
date_list = [df_close.index[0]]
for row in df_close.iterrows():
if h % 42 == 0:
date_list.append(row[0])
lower_index = lower_index * (row[1][lower_symbols] / lower_prices).mean()
lower_index_list.append(lower_index)
lower_symbols = row[1].dropna().sort_values()[:20].index
lower_prices = row[1][lower_symbols]
h += 1
pd.DataFrame(data=lower_index_list,index=date_list).plot(figsize=(12,5),grid=True);
total_index.plot(figsize=(12,5),grid=True); #overall index
```
https://stocksharp.com/file/149322
### Performance of Small Market Cap Currencies
Due to the constantly changing circulation, the market value calculation here uses the total supply volume, with data sourced from Coincapmarket. Those who need it can apply for a key. A total of 1000 currencies with the highest market values were selected. Due to naming methods and unknown total supplies, we obtained 205 currencies that overlap with Binance perpetual contracts.
```
import requests

def get_latest_crypto_listings(api_key):
url = "https://pro-api.coinmarketcap.com/v1/cryptocurrency/listings/latest?limit=1000"
headers = {
'Accepts': 'application/json',
'X-CMC_PRO_API_KEY': api_key,
}

response = requests.get(url, headers=headers)
if response.status_code == 200:
return response.json()
else:
return f"Error: {response.status_code}"

# Use your API key
api_key = "xxx"
coin_data = get_latest_crypto_listings(api_key)
supplys = {d['symbol']: d['total_supply'] for d in coin_data['data']}
include_symbols = [s for s in list(df_close.columns) if s in supplys and supplys[s] > 0 ]
```
An index is drawn from the 10 cryptocurrencies with the lowest market value each week, and compared with the overall index. It can be seen that small-cap cryptocurrencies performed slightly better than the overall index in the bull market at the beginning of the year. However, they started to rise ahead of time during September-October's sideways movement, and their final increase far exceeded that of the total index.

Small-cap cryptocurrencies are often considered to have higher growth potential. Because their market values are low, even relatively small inflows of funds can cause significant price changes. This potential for high returns attracts investors and speculators' attention. When there is a stir at bottom markets, due to less resistance to rise, small-cap currencies often take off first and may even indicate that a general rising bull market is about to begin.

```
df_close_include = df_close[include_symbols]
df_norm = df_close_include/df_close_include.fillna(method='bfill').iloc[0] #Normalization
total_index = df_norm.mean(axis=1)
h = 1
N = 10
lower_index = 1
lower_index_list = [1]
lower_symbols = df_close_include.iloc[0].dropna().multiply(pd.Series(supplys)[include_symbols], fill_value=np.nan).sort_values()[:N].index
lower_prices = df_close_include.iloc[0][lower_symbols]
date_list = [df_close_include.index[0]]
for row in df_close_include.iterrows():
if h % 42 == 0:
date_list.append(row[0])
lower_index = lower_index * (row[1][lower_symbols] / lower_prices).mean()
lower_index_list.append(lower_index)
lower_symbols = row[1].dropna().multiply(pd.Series(supplys)[include_symbols], fill_value=np.nan).sort_values()[:N].index
lower_prices = row[1][lower_symbols]
h += 1
pd.DataFrame(data=lower_index_list,index=date_list).plot(figsize=(12,5),grid=True);
total_index.plot(figsize=(12,5),grid=True);
```
https://stocksharp.com/file/149323
### Summary
This article, through data analysis, found that low-priced currencies did not provide additional returns and their performance was close to the market index. The performance of small market cap currencies significantly exceeded the overall index increase. Below is a list of contract currencies with a market value less than 100 million U for reference, even though we are currently in a bull market.

'HOOK': 102007225,
'SLP': 99406669,
'NMR': 97617143,
'RDNT': 97501392,
'MBL': 93681270,
'OMG': 89129884,
'NKN': 85700948,
'DENT': 84558413,
'ALPHA': 81367392,
'RAD': 80849568,
'HFT': 79696303,
'STMX': 79472000,
'ALICE': 74615631,
'OGN': 74226686,
'GTC': 72933069,
'MAV': 72174400,
'CTK': 72066028,
'UNFI': 71975379,
'OXT': 71727646,
'COTI': 71402243,
'HIGH': 70450329,
'DUSK': 69178891,
'ARKM': 68822057,
'HIFI': 68805227,
'CYBER': 68264478,
'BADGER': 67746045,
'AGLD': 66877113,
'LINA': 62674752,
'PEOPLE': 62662701,
'ARPA': 62446098,
'SPELL': 61939184,
'TRU': 60944721,
'REN': 59955266,
'BIGTIME': 59209269,
'XVG': 57470552,
'TLM': 56963184,
'BAKE': 52022509,
'COMBO': 47247951,
'DAR': 47226484,
'FLM': 45542629,
'ATA': 44190701,
'MDT': 42774267,
'BEL': 42365397,
'PERP': 42095057,
'REEF': 41151983,
'IDEX': 39463580,
'LEVER': 38609947,
'PHB': 36811258,
'LIT': 35979327,
'KEY': 31964126,
'BOND': 29549985,
'FRONT': 29130102,
'TOKEN': 28047786,
'AMB': 24484151
From: https://blog.mathquant.c...-value-or-low-price.html

Seamless Setup: Installing Interactive Brokers IB Gateway on Linux with Easy-to-Follow Instructions

2024-03-19T01:24:32Z

FMZ platform now supports the integration of Interactive Brokers (IB). It's quite simple on Windows, so we won't explain how to install it here. For Linux users who generally rent servers without a graphical interface and only have SSH, the installation is more challenging. This article will explain how to install IB Gateway for quantitative trading. We usually choose to install IB Gateway instead of TWS client, because the TWS client shuts down periodically and is not suitable for quantitative trading. Here we take Debian as an example:

**Step 1: Install Desktop Services and VNC**

First, you need to install desktop services and a VNC server to enable remote desktop access. Here, we will use xfce and TightVNC as examples. Execute the following commands in the terminal to install:

```
sudo apt update
sudo apt install xfce4 xfce4-goodies dbus-x11
sudo apt install tightvncserver
tightvncserver
```
Please note that the maximum length for the password during installation is 8 characters. Please set a highly secure password. The default startup port for the first session is 5901.

**Step 2: Connect to VNC and Install IB Gateway**

The default address is ```vnc://IP Address:5901```, you can log in by entering the password. For Windows, please download and install the VNC client yourself.

Download page: https://www.interactiveb...ng/ibgateway-stable.php
Please use a tool similar to wget for downloading. If you can't find the corresponding version, please click on "Download for Other Operating Systems" on the page to search.

```
wget https://download2.intera...standalone-linux-x64.sh
```
If it's inconvenient to download within VNC, you can initiate a separate SSH download and then install it under the VNC desktop environment.

```
bash ibgateway-stable-standalone-linux-x64.sh
```
The interface can already be displayed here, you can manually run the installation directory directly by running ```./ibgateway```.
https://stocksharp.com/file/149319
After installation, log in and find the API option. Make sure to uncheck "Read-Only API". The port number is also in the settings. Please configure the exchange correctly according to this port number.
https://stocksharp.com/file/149320
The exchange is configured as follows: Client ID. If you have multiple robots that need to connect, this needs to be set to different IDs, as IB does not allow the same Client ID to connect simultaneously.
https://stocksharp.com/file/149321
It should be noted that localhost and 127.0.0.1 are not the same network address at the lower level of the Linux operating system, here we use localhost.

IB's market data requires a paid subscription. If you need real-time ticker and depth information, please subscribe for a fee, otherwise you can only receive delayed tickers.

From: https://blog.mathquant.c...teway-in-linux-bash.html

Harness the Power of FMZ Extended API: A Step-by-Step Guide to Batch Modify Bot Parameters with Ease

2024-03-18T08:56:55Z

How can I change the parameters of live tradings in batch on FMZ? When the number of live tradings exceeds dozens and reaches hundreds, it would be very inconvenient to configure live tradings one by one manually. At this time, we can use the FMZ extended API to complete these operations. So in this article, we will explore the group control of the bot, update some details of the parameters.

In the previous article, we solved the problem of how to use the FMZ extended API to monitor all the live tradings, group control live tradings, and send commands to the live tradings. And we still use the interface call code we encapsulated in the previous article as a basis, continue to write code to realize the batch modification of the parameters of the live trading.

Parameter settings:
https://stocksharp.com/file/149294
Strategy code:

```
// Global variable
var isLogMsg = true // Controls whether logs are printed or not
var isDebug = false // Debugging mode
var arrIndexDesc = ["all", "running", "stop"]
var descRobotStatusCode = ["Idle", "Running", "Stopping", "Exited", "Stopped", "There is an error in the strategy"]
var dicRobotStatusCode = {
"all" : -1,
"running" : 1,
"stop" : 4,
}

// Extended logging functions
function LogControl(...args) {
if (isLogMsg) {
Log(...args)
}
}

// FMZ extended API call functions
function callFmzExtAPI(accessKey, secretKey, funcName, ...args) {
var params = {
"version" : "1.0",
"access_key" : accessKey,
"method" : funcName,
"args" : JSON.stringify(args),
"nonce" : Math.floor(new Date().getTime())
}

var data = `${params["version"]}|${params["method"]}|${params["args"]}|${params["nonce"]}|${secretKey}`
params["sign"] = Encode("md5", "string", "hex", data)

var arrPairs = []
for (var k in params) {
var pair = `${k}=${params[k]}`
arrPairs.push(pair)
}
var query = arrPairs.join("&")

var ret = null
try {
LogControl("url:", baseAPI + "/api/v1?" + query)
ret = JSON.parse(HttpQuery(baseAPI + "/api/v1?" + query))
if (isDebug) {
LogControl("Debug:", ret)
}
} catch(e) {
LogControl("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}
Sleep(100) // Control frequency
return ret
}

// Get information about all running bots for the specified strategy Id.
function getAllRobotByIdAndStatus(accessKey, secretKey, strategyId, robotStatusCode, maxRetry) {
var retryCounter = 0
var length = 100
var offset = 0
var arr = []

if (typeof(maxRetry) == "undefined") {
maxRetry = 10
}

while (true) {
if (retryCounter > maxRetry) {
LogControl("Maximum number of retries exceeded", maxRetry)
return null
}
var ret = callFmzExtAPI(accessKey, secretKey, "GetRobotList", offset, length, robotStatusCode)
if (!ret || ret["code"] != 0) {
Sleep(1000)
retryCounter++
continue
}

var robots = ret["data"]["result"]["robots"]
for (var i in robots) {
if (robots[i].strategy_id != strategyId) {
continue
}
arr.push(robots[i])
}

if (robots.length < length) {
break
}
offset += length
}

return arr
}
```
### Get to Know the RestartRobot Function of the FMZ Extended API First
When we need to batch modify the parameters of the live trading and then run it, there are 2 cases for this scenario to begin with.

- 1. Bot has been created
For a live trading that has already been created, it is natural to restart it using the RestartRobot function, which is an extended API interface to FMZ.
- 2. Bot has not been created
For the live trading has not been created, there is no need to "modify" the parameters of the live trading, that's the batch creation of the live trading to run, and we use FMZ extended API interface - NewRobot function.

But no matter what kind of method, the next idea as well as the operation are similar, so we will use the ```RestartRobot``` extended API function as an example to explain.

RestartRobot function is used in two ways:

- 1. Configuration with only live trading ID passed in, not the parameters of live trading
This approach keeps the parameter configuration unchanged when the live trading stopped, and restarts the live trading only.
- 2. Configuration with live trading ID and the parameters of live trading passed in
This approach starts the live trading running with the new parameter configuration.

The first approach is not useful for our demand scenario, because our own demand is to modify a large number of parameters of the live trading in bulk. So the question is, the configuration of the parameters of the live trading is very complex, there are exchange object configuration, strategy parameter configuration, K-line period settings and so on.

Do not worry, let's explore them one by one.

### Get the Information of the Live Trading You Want to Operate
On FMZ, if you want to modify the parameter configuration of a live trading, then it must be non-running. Because only a live trading that is not running can have its parameter configuration modified. A live trading that is not in the running state may be in:

- The strategy stopped.
- Strategy has errors, stopped.

So we need to get the live tradings for the specified strategy first, and these live tradings are in a **stopped state** or **have an error to stop**.

```
function main() {
var stopRobotList = getAllRobotByIdAndStatus(accessKey, secretKey, strategyId, 4)
var errorRobotList = getAllRobotByIdAndStatus(accessKey, secretKey, strategyId, 5)
var robotList = stopRobotList.concat(errorRobotList)
}
```
This gives us all the information about the live trading that we need to change the configuration of, next we will get the detailed configuration of the live trading.

### Modification of Live Trading Configuration Parameters
For example, the live trading strategy for which we need to modify the parameters is as follows (i.e., the strategy whose strategy ID is the strategyId variable):
https://stocksharp.com/file/149295
https://stocksharp.com/file/149296
The strategy has 3 parameters as a test.

Modify the strategy parameters for the live trading, but maybe we don't want to modify the strategy's exchange configuration, but for the Extended API interface RestartRobot function, either no parameters are specified (as is just start the live trading) or all parameter configurations must be specified.

That is to say, before we use the RestartRobot function to start the live trading, we must use the extended API interface GetRobotDetail function to get the current configuration of the live trading first, and then we replace the part of the parameters that need to be modified, to re-construct the configuration parameters for the start of the live trading (i.e., the parameters that will be used to call RestartRobot), and then restart the live trading.

So, next we traverse robotList, and get the current parameter configuration one by one, the ```/**/``` commented part of the following code is the live trading details, we need to deal with these data.

```
function main() {
var stopRobotList = getAllRobotByIdAndStatus(accessKey, secretKey, strategyId, 4)
var errorRobotList = getAllRobotByIdAndStatus(accessKey, secretKey, strategyId, 5)

var robotList = stopRobotList.concat(errorRobotList)
_.each(robotList, function(robotInfo) {
var robotDetail = callFmzExtAPI(accessKey, secretKey, "GetRobotDetail", robotInfo.id)

/*
{
"code": 0,
"data": {
"result": {
"robot": {
...
"id": 130350,
...
"name": "Test 1B",
"node_id": 3022561,
...
"robot_args": "[[\"pairs\",\"BTC_USDT,ETH_USDT,EOS_USDT,LTC_USDT\"],[\"col\",3],[\"htight\",300]]",
"start_time": "2023-11-19 21:16:12",
"status": 5,
"strategy_args": "[[\"pairs\",\"Currency list\",\"English comma spacing\",\"BTC_USDT,ETH_USDT,EOS_USDT,LTC_USDT\"],[\"col\",\"breadth\",\"Total width of the page is 12\",6],[\"htight\",\"height\",\"unit px\",600],[\"$$$__cmd__$$$coverSymbol\",\"close the position\",\"close out trading pairs\",\"\"]]",
"strategy_exchange_pairs": "[3600,[186193],[\"BTC_USD\"]]",
"strategy_id": 131242,
"strategy_last_modified": "2023-12-09 23:14:33",
"strategy_name": "Test 1",
...
}
},
"error": null
}
}
*/

// Parse the exchange configuration data
var exchangePairs = JSON.parse(robotDetail.data.result.robot.strategy_exchange_pairs)

// Get the exchange object index, trading pairs, these settings are not going to be changed
var arrExId = exchangePairs[1]
var arrSymbol = exchangePairs[2]

// Parse parameter configuration data
var params = JSON.parse(robotDetail.data.result.robot.robot_args)

// Update parameters
var dicParams = {
"pairs" : "AAA_BBB,CCC_DDD",
"col" : "999",
"htight" : "666"
}

var newParams = []
_.each(params, function(param) {
for (var k in dicParams) {
if (param[0] == k) {
newParams.push([k, dicParams[k]]) // Construct the strategy parameters and update the new parameter values
}
}
})

// Note that if there are spaces in the data you need to transcode it, otherwise the request will report an error
settings = {
"name": robotDetail.data.result.robot.name,
// Strategy parameter
"args": newParams,
// The strategy ID can be obtained by the GetStrategyList method.
"strategy": robotDetail.data.result.robot.strategy_id,
// K-period parameter, 60 means 60 seconds
"period": exchangePairs[0],
// Specifies which docker to run on; not writing this attribute means automatically assigning the run
"node" : robotDetail.data.result.robot.node_id,
"exchanges": []
}

for (var i = 0 ; i < arrExId.length ; i++) {
settings["exchanges"].push({"pid": arrExId[i], "pair": arrSymbol[i]})
}
Log(settings) // Test
var retRestart = callFmzExtAPI(accessKey, secretKey, "RestartRobot", robotInfo.id, settings)
Log("retRestart:", retRestart)
})
}
```
After running the batch parameter modification strategy, my live trading:

- Test 1A
- Test 1B

Batch modification of parameters was done with the configured exchange objects, trading pairs and K-line periods unchanged:

It was changed on the live trading page automatically:
https://stocksharp.com/file/149297
And start running. Because we specified the modified parameters in the code above:

```
// Update parameters
var dicParams = {
"pairs" : "AAA_BBB,CCC_DDD",
"col" : "999",
"htight" : "666"
}
```
### END
For dozens, hundreds of live trading batch modify parameters, this method is more convenient. In the example, the parameters are modified to a uniform, of course you can customize your own modification rules in the code to specify different parameter configurations for each live trading. Or specify different exchange objects, trading pairs and so on.

For the FMZ platform, these requirements are flexible and customizable to achieve. Feel free to leave a comment if you have any requirement ideas, we can discuss, research and learn from each other , and find the solution to the problem.

From: https://blog.mathquant.c...rameters-of-the-bot.html

Unlocking the Secrets of Perpetual Contract Grid Strategy Parameter Optimization with Python Backtesting

2024-03-18T05:23:38Z

The perpetual grid strategy is a popular classic strategy on FMZ platform. Compared with the spot grid, there is no need to have currencies, and leverage can be added, which is much more convenient than the spot grid. However, since it is not possible to backtest on the FMZ Quant Platform directly, it is not conducive to screening currencies and determining parameter optimization. In this article, we will introduce the complete Python backtesting process, including data collection, backtesting framework, backtesting functions, parameter optimization, etc. You can try it yourself in juypter notebook.

### Data Collection
Generally, it is enough to use K-line data. For accuracy, the smaller the K-line period, the better. However, to balance the backtest time and data volume, in this article, we use 5min of data from the past two years for backtesting. The final data volume exceeded 200,000 lines. We choose DYDX as the currency. Of course, the specific currency and K-line period can be selected according to your own interests.

```
import requests
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import requests, zipfile, io
%matplotlib inline

def GetKlines(symbol='BTC',start='2020-8-10',end='2021-8-10',period='1h'):
Klines = []
start_time = int(time.mktime(datetime.strptime(start, "%Y-%m-%d").timetuple()))*1000
end_time = int(time.mktime(datetime.strptime(end, "%Y-%m-%d").timetuple()))*1000
while start_time < end_time:
res = requests.get('https://fapi.binance.com/fapi/v1/klines?symbol=%sUSDT&interval=%s&startTime=%s&limit=1000'%(symbol,period,start_time))
res_list = res.json()
Klines += res_list
start_time = res_list[-1][0]
return pd.DataFrame(Klines,columns=['time','open','high','low','close','amount','end_time','volume','count','buy_amount','buy_volume','null']).astype('float')

df = GetKlines(symbol='DYDX',start='2022-1-1',end='2023-12-7',period='5m')
df = df.drop_duplicates()
```
### Backtesting Framework
For backtesting, we continue to choose the commonly used framework that supports USDT perpetual contracts in multiple currencies, which is simple and easy to use.

```
class Exchange:

def __init__(self, trade_symbols, fee=0.0004, initial_balance=10000):
self.initial_balance = initial_balance #Initial assets
self.fee = fee
self.trade_symbols = trade_symbols
self.account = {'USDT':{'realised_profit':0, 'unrealised_profit':0, 'total':initial_balance, 'fee':0}}
for symbol in trade_symbols:
self.account[symbol] = {'amount':0, 'hold_price':0, 'value':0, 'price':0, 'realised_profit':0,'unrealised_profit':0,'fee':0}

def Trade(self, symbol, direction, price, amount):

cover_amount = 0 if direction*self.account[symbol]['amount'] >=0 else min(abs(self.account[symbol]['amount']), amount)
open_amount = amount - cover_amount
self.account['USDT']['realised_profit'] -= price*amount*self.fee #Deduction of handling fee
self.account['USDT']['fee'] += price*amount*self.fee
self.account[symbol]['fee'] += price*amount*self.fee

if cover_amount > 0: #Close the position first.
self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount #Profits
self.account[symbol]['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount

self.account[symbol]['amount'] -= -direction*cover_amount
self.account[symbol]['hold_price'] = 0 if self.account[symbol]['amount'] == 0 else self.account[symbol]['hold_price']

if open_amount > 0:
total_cost = self.account[symbol]['hold_price']*direction*self.account[symbol]['amount'] + price*open_amount
total_amount = direction*self.account[symbol]['amount']+open_amount

self.account[symbol]['hold_price'] = total_cost/total_amount
self.account[symbol]['amount'] += direction*open_amount

def Buy(self, symbol, price, amount):
self.Trade(symbol, 1, price, amount)

def Sell(self, symbol, price, amount):
self.Trade(symbol, -1, price, amount)

def Update(self, close_price): #Updating of assets
self.account['USDT']['unrealised_profit'] = 0
for symbol in self.trade_symbols:
self.account[symbol]['unrealised_profit'] = (close_price[symbol] - self.account[symbol]['hold_price'])*self.account[symbol]['amount']
self.account[symbol]['price'] = close_price[symbol]
self.account[symbol]['value'] = abs(self.account[symbol]['amount'])*close_price[symbol]
self.account['USDT']['unrealised_profit'] += self.account[symbol]['unrealised_profit']
self.account['USDT']['total'] = round(self.account['USDT']['realised_profit'] + self.initial_balance + self.account['USDT']['unrealised_profit'],6)
```
### Grid Backtest Function
The principle of the grid strategy is very simple. Sell when the price rises and buy when the price falls. It specifically involves three parameters: initial price, grid spacing, and trading value. The market of DYDX fluctuates greatly. It fell from the initial low of 8.6U to 1U, and then rose back to 3U in the recent bull market. The default initial price of the strategy is 8.6U, which is very unfavorable for the grid strategy, but the default parameters backtested a total profit of 9200U was made in two years, and a loss of 7500U was made during the period.
https://stocksharp.com/file/149291
```
symbol = 'DYDX'
value = 100
pct = 0.01

def Grid(fee=0.0002, value=100, pct=0.01, init = df.close[0]):
e = Exchange([symbol], fee=0.0002, initial_balance=10000)
init_price = init
res_list = [] #For storing intermediate results
for row in df.iterrows():
kline = row[1] #To backtest a K-line will only generate one buy order or one sell order, which is not particularly accurate.
buy_price = (value / pct - value) / ((value / pct) / init_price + e.account[symbol]['amount']) #The buy order price, as it is a pending order transaction, is also the final aggregated price
sell_price = (value / pct + value) / ((value / pct) / init_price + e.account[symbol]['amount'])
if kline.low < buy_price: #The lowest price of the K-line is lower than the current pending order price, the buy order is filled
e.Buy(symbol,buy_price,value/buy_price)
if kline.high > sell_price:
e.Sell(symbol,sell_price,value/sell_price)
e.Update({symbol:kline.close})
res_list.append([kline.time, kline.close, e.account[symbol]['amount'], e.account['USDT']['total']-e.initial_balance,e.account['USDT']['fee'] ])
res = pd.DataFrame(data=res_list, columns=['time','price','amount','profit', 'fee'])
res.index = pd.to_datetime(res.time,unit='ms')
return res
```
https://stocksharp.com/file/149292
### Initial Price Impact
The setting of the initial price affects the initial position of the strategy. The default initial price for the backtest just now is the initial price at startup, that is, no position is held at startup. And we know that the grid strategy will realize all profits when the price returns to the initial stage, so if the strategy can correctly predict the future market when it is launched, the income will be significantly improved. Here, we set the initial price to 3U and then backtest. In the end, the maximum drawdown was 9200U, and the final profit was 13372U. The final strategy does not hold positions. The profit is all the fluctuation profits, and the difference between the profits of the default parameters is the position loss caused by inaccurate judgment of the final price.

However, if the initial price is set to 3U, the strategy will go short at the beginning and hold a large number of short positions. In this example, a short order of 17,000 U is directly held, so it faces greater risks.
https://stocksharp.com/file/149293
### Grid Spacing Settings
The grid spacing determines the distance between pending orders. Obviously, the smaller the spacing, the more frequent the transactions, the lower the profit of a single transaction, and the higher the handling fee. However, it is worth noting that as the grid spacing becomes smaller and the grid value remains unchanged, when the price changes, the total positions will increase, and the risks faced are completely different. Therefore, to backtest the effect of grid spacing, it is necessary to convert the grid value.

Since the backtest uses 5m K-line data, and each K-line is only traded once, which is obviously unrealistic, especially since the volatility of digital currencies is very high. A smaller spacing will miss many transactions in backtesting compared with the live trading. Only a larger spacing will have reference value. In this backtesting mechanism, the conclusions drawn are not accurate. Through tick-level order flow data backtesting, the optimal grid spacing should be 0.005-0.01.

```
for p in [0.0005, 0.001 ,0.002 ,0.005, 0.01, 0.02, 0.05]:
res = Grid( fee=0.0002, value=value*p/0.01, pct=p, init =3)
print(p, round(min(res['profit']),0), round(res['profit'][-1],0), round(res['fee'][-1],0))

0.0005 -8378.0 144.0 237.0
0.001 -9323.0 1031.0 465.0
0.002 -9306.0 3606.0 738.0
0.005 -9267.0 9457.0 781.0
0.01 -9228.0 13375.0 550.0
0.02 -9183.0 15212.0 309.0
0.05 -9037.0 16263.0 131.0
```
### Grid Transaction Value
As mentioned before, when the fluctuations are the same, the greater the value of the holding, the risk is proportional. However, as long as there is no rapid decline, 1% of the total funds and 1% of the grid spacing should be able to cope with most market conditions. In this DYDX example, a drop of almost 90% also triggered a liquidation. However, it should be noted that DYDX mainly falls. When the grid strategy goes long when it falls, it will fall by 100% at most, while there is no limit on the rise, and the risk is much higher. Therefore, Grid Strategy recommends users to choose only the long position mode for currencies they believe have potential.

From: https://blog.mathquant.c...ameter-optimization.html

How to Exploit Brainless Selling Bots with a High-Frequency Strategy in 80 Lines of Code

2024-03-18T01:37:44Z

# How to Exploit Brainless Selling Bots with a High-Frequency Strategy in 80 Lines of Code

### Opportunity Observation
Recently, I found that Binance has a currency STORJ market is very strange unintentionally when I was watching the market, the trading volume is very large, and the trading frequency is very fast, the specific one-minute K-line of the following chart, we can see that the trading volume of each minute are consistent, and the minute K-line can be seen in a long lower shadow line.
https://stocksharp.com/file/149286
Observe with Binance 1-second K-line, I found out the end of the story, someone is marketed 10,000-20,000 STORJs every 5-7s, regardless of the cost, and smashing a small hole in the K-line directly, while the price recovers in the short term. This operation was obviously caused by a robot on an iceberg commission. This selling operation lasted for a very long time, totaling an estimated $10 million level, and in many cases caused slippage of up to 0.1%, which means that the executor of this strategy lost tens of thousands of dollars in slippage on the trade only. But with such a mechanical operation and active trading, there was a clear opportunity for market making scalping.
https://stocksharp.com/file/149288
A simple change to the original spot HF strategy, and in a few minutes I got this bot that specializes in exploiting this brainless sale of iceberg commissions.

### Strategy Idea
Since the market sells in market price every few seconds, we just need to find the 10k depth in the buy order book and hang the order in front of it. So that when the iceberg sells, a high probability that the market-making robot just can receive, and at this time the transaction is very active, the momentary price decline also triggered some buy orders. By the same token, hanging sell orders can be thrown in the trend, so repeated operations. The frequency of transactions is very high, even if each time the yield is not large, the total return is also quite substantial. Of course, the premise of everything is to have a low-fee account, if the buying and selling fees both are 0.1%, then the space is not enough to pay the fees.

### Strategy Performance
The strategy is performing as follows, at first, none of the profits were printing, so I changed it this afternoon, and print out the profits, the crazy selling robots have changed the volume to about 5000 at a time, so it's past the optimal time for arbitrage. I'm probably making 100-200U per hour at first, the key is risk free and low cost. On the flip side, the iceberg commission actually has a lot of skills, if you know how to write a strategy, you can spend ten minutes on FMZ to write the iceberg commission strategy that observes the depth of the buy order to decide the size and price of the order, observes the size of the active buy order to adjust the size of the pending order and take up the market monitoring and other characteristics, saving tens of thousands of dollars easily.
https://stocksharp.com/file/149289
### Strategy Source Code
The strategy code is very simple, only 80 lines, which is suitable for beginners, here are some of the parameters such as order precision and so on written fixed in the program, you can change the parameters as follows. It is recommended to save it, in case of any exchange trading pairs or the traders are out of control, you can fell free to charge them some interest at any time.
https://stocksharp.com/file/149290
```
function CancelPendingOrders() {
var orders = _C(exchange.GetOrders)
for (var j = 0; j < orders.length; j++) {
exchange.CancelOrder(orders[j].Id, orders[j])
}
}

function onexit(){
CancelPendingOrders()
}

function GetPrice(Type, Depth) {
var sumAmount = 0
var checkAmount = Type == "Buy" ? CheckBuyAmount : CheckSellAmount
var deep = Type == "Buy" ? Depth.Bids : Depth.Asks
for(var i = 0; i < Math.min(20, deep.length); i++) {
if(Type == "Buy" && deep[i].Price == lastBuyPrice && buyId){
sumAmount += deep[i].Amount - amountBuy //Subtract your own pending orders here
}else if(Type == "Sell" && deep[i].Price == lastSellPrice && sellId){
sumAmount += deep[i].Amount - amountSell
}else{
sumAmount += deep[i].Amount
}
if(sumAmount >= checkAmount){
return deep[i].Price
}
}
return deep[19].Price
}

function OnTick() {
var depth = _C(exchange.GetDepth)
var buyPrice = _N(Math.min(GetPrice("Buy", depth) + 0.0001, depth.Asks[0].Price-0.0001) , 4) //Guaranteed at the market
var sellPrice = _N(Math.max(GetPrice("Sell", depth) - 0.0001, depth.Bids[0].Price+0.0001), 4)
LogStatus('buy_price:'+buyPrice, ' sell price: '+sellPrice)
if ((sellPrice - buyPrice) < DiffPrice) {
buyPrice = 0
}
if(sellPrice != lastSellPrice && sellId){
exchange.CancelOrder(sellId);
sellId = 0
lastSellPrice = 0
}
if(buyPrice != lastBuyPrice && buyId){
exchange.CancelOrder(buyId);
buyId = 0
lastBuyPrice = 0
}
var acc = _C(exchange.GetAccount)
if(account.Stocks+account.FrozenStocks != acc.Stocks+acc.FrozenStocks){
LogProfit((acc.Stocks+acc.FrozenStocks)*depth.Bids[0].Price+acc.Balance+acc.FrozenBalance - 2000)
Log('free '+acc.Stocks, ' lock: '+ acc.FrozenStocks, ' total: ' , (acc.Stocks+acc.FrozenStocks)*depth.Bids[0].Price+acc.Balance+acc.FrozenBalance)
}
account = acc
amountBuy = _N(Math.min(account.Balance / buyPrice - 0.1, Amount), 0)
amountSell = _N(account.Stocks, 0)
if (sellPrice > 0 && amountSell > 40 && sellId == 0) {
sellId = exchange.Sell(_N(sellPrice,4), amountSell)
lastSellPrice = sellPrice
}
if (buyPrice>0 && amountBuy > 40 && buyId == 0) {
buyId = exchange.Buy(_N(buyPrice,4), amountBuy)
lastBuyPrice = buyPrice
}
Sleep(Interval)
}
var account = {Stocks:0, FrozenStocks:0, Balance:0, FrozenBalance:0}
var buyId = 0
var sellId = 0
var lastBuyPrice = 0
var lastSellPrice = 0
var amountSell = 0
var amountBuy = 0
var log_account_time = 0
function main() {
CancelPendingOrders()
while (true) {
OnTick()
}
}
```
From: https://blog.mathquant.c...in-80-lines-of-code.html

An Analysis of Common Requirements Design Examples in the Cryptocurrency Market (II)

2024-03-15T06:42:30Z

# FMZ Quant: An Analysis of Common Requirements Design Examples in the Cryptocurrency Market (II)

In response to the comments from readers in the previous article, they requested a program example for monitoring contract account transfers. In this article, we will use Binance exchange as the test object to implement the requirement and learn how to design it together.

Cryptocurrency exchanges handle a large number of transactions every day, including the transfer of assets between different wallets. Monitoring these transfers in real time is crucial for traders and developers. In this article, we will explore a piece of JavaScript code designed to monitor recent asset transfers on a cryptocurrency exchange and discuss its key components.

### Analyze Requirements
I checked the documentation of Binance exchange and found that there is a transfer history interface that can query all transfer information. Since we are only monitoring transfer records that may occur, we do not need to obtain all transfer history. We only need to check recent transfer records within a certain range based on a certain frequency. If new transfer records are found, they will be updated and notified.

Use the interface:

```
// GET /sapi/v1/asset/transfer type, size : 100
```
So how to check the newly added transfer record? After reading Binance's documentation, I found that there is a timestamp in the data returned by this interface. It is very simple to judge by the timestamp. As long as there is a record larger than the maximum timestamp currently recorded, it means that a new transfer action has occurred. Just use this to trigger it.

The ```/sapi/v1/asset/transfer``` interface can request up to 100 pieces of data at a time. The detection will not cause problems for low-frequency transfers, unless the account has more than 100 transfer operations between the end of one detection and the start of the next detection. At this time, some new operation records may be missed, which is sufficient for general demand scenarios (generally, there will be no strategy to transfer funds crazily...).

Of course, there are many details in the actual design. For example, checking the documentation, we found that there are many transfer directions, so we need to monitor each transfer direction. The code is defined ```var dicType = {...}``` to manage all transfer directions.

In order to display the content better, we use a status bar table to output the last 5 transfer information in the strategy interface, so we constructed an object named ```monitor``` to record the data. Of course, you cannot record transfer information unlimitedly, so we only maintain 100 records for each transfer direction. If the number exceeds 100, we will delete premature records.

### Code Example
```
function getRecentTransferHistory(TransType, typeDesc) {
// GET /sapi/v1/asset/transfer type, size : 100

var rows = null
var ret = exchange.IO("api", "GET", "/sapi/v1/asset/transfer", `type=${TransType}&size=100`)
Log("/sapi/v1/asset/transfer" + `type=${TransType}&size=100`)
if (ret && typeof(ret.rows) != "undefined" && Array.isArray(ret.rows)) {
rows = ret.rows
} else if (ret && typeof(ret.total) != "undefined" && ret.total == 0) {
rows = []
} else {
Log(TransType, typeDesc, "inquiry failure", ret)
}

return rows
}

var monitor = {}
function monitorTransfers() {
var dicType = {
"MAIN_UMFUTURE": "Spot wallet --> U-based contract wallet",
"MAIN_CMFUTURE": "Spot wallet --> Currency-based contract wallet",
"UMFUTURE_MAIN": "U-based contract wallet --> Spot wallet",
"UMFUTURE_MARGIN": "U-based contract wallet --> Leveraged full position wallet",
"CMFUTURE_MAIN": "Currency-based contract wallet --> Spot wallet",
"MARGIN_UMFUTURE": "Leveraged full position wallet --> U-based contract wallet",
"MARGIN_CMFUTURE": "Leveraged full position wallet --> Currency-based contract wallet",
"CMFUTURE_MARGIN": "Currency-based contract wallet --> Leveraged full position wallet",
"FUNDING_UMFUTURE": "Funds wallet --> U-based contract wallet",
"UMFUTURE_FUNDING": "U-based contract wallet --> Funds wallet",
"FUNDING_CMFUTURE": "Funds wallet --> Currency-based contract wallet",
"CMFUTURE_FUNDING": "Currency-based contract wallet --> Funds wallet",
"UMFUTURE_OPTION": "U-based contract wallet --> Options wallet",
"OPTION_UMFUTURE": "Options wallet --> U-based contract wallet",
// integrated account
"MAIN_PORTFOLIO_MARGIN": "Spot wallet --> Unified accounts wallet",
"PORTFOLIO_MARGIN_MAIN": "Unified accounts wallet --> Spot wallet"
}

Log("start testing")
_.each(dicType, function(v, k) {
var rows = getRecentTransferHistory(k, v)
var maxTS = 0
_.each(rows, function(row) {
if (typeof(monitor[k]) == "undefined") {
monitor[k] = {"transType": k, "typeDesc": v, "recentRecords": [], "lastTS": 0}
}

if (row["timestamp"] > monitor[k]["lastTS"]) {
monitor[k]["recentRecords"].push(row)

if (monitor[k]["lastTS"] != 0) {
Log("New transfer records detected", k, v, row, "#FF0000")
}
}
maxTS = Math.max(maxTS, row["timestamp"])
})
if (rows && rows.length == 0) {
return
}
monitor[k]["lastTS"] = maxTS

var sortedArrayAscending = monitor[k]["recentRecords"].slice().sort((a, b) => a.timestamp - b.timestamp)
monitor[k]["recentRecords"] = sortedArrayAscending

if (monitor[k]["recentRecords"].length > 100) {
monitor[k]["recentRecords"].shift()
}
Sleep(1000)
})
Log("commencement and termination")
}

function main() {
LogReset()
while (true) {
monitorTransfers()

var tbls = []
_.each(monitor, function(v, k) {
var tbl = {
"type": "table",
"title": v["typeDesc"],
"cols": ["asset", "amount", "status", "tranId", "time"],
"rows": []
}

var arr = v["recentRecords"].slice().sort((a, b) => b.timestamp - a.timestamp)
for (var i = 0; i < arr.length; i++) {
if (i < 5) {
tbl["rows"].push([arr[i]["asset"], arr[i]["amount"], arr[i]["status"], arr[i]["tranId"], _D(arr[i]["timestamp"])])
}
}
tbls.push(tbl)
})

LogStatus(_D(), "\n", "`" + JSON.stringify(tbls) + "`")
Sleep(1000 * 30)
}
}
```
### Code Overview:
The provided JavaScript code includes several functions that build a system together for monitoring recent asset transfers. Let's analysis the main components:

- getRecentTransferHistory function:

Purpose: Obtain the recent asset transfer history from the exchange API according to the specified parameters.
Parameters: TransType (transfer type), typeDesc (type description).
API endpoint: /sapi/v1/asset/transfer.

- monitorTransfers function:

Purpose: Iterate over predefined transfer types, retrieve recent transfer history, and record any new transfers.
Use a dictionary (dicType) to map transfer types to human-readable descriptions.
Update the monitor object to track the latest transfers of each type.

- main function:

Purpose: Run an infinite loop that monitors transfers continuously and displays the latest data.
Use the monitorTransfers function regularly.
Generate a table for each transfer type, including columns such as asset, amount, status, transaction ID, and timestamp.

### Key Features:
- Dynamic transfer type mapping:

The code uses a dictionary (dicType) to map transfer types to descriptive names, providing a clear explanation of the nature of each transfer.

- Real-time monitoring:

The system checks for new transfers continuously, updates the monitor object and records any detected changes.

- Data presentation:

Use tables to present each type of transfer data, including relevant details such as assets, amounts, status, transaction IDs, and timestamps.

- Recent transfer history management:

Maintain a scrolling list of recent transfer records for each type, ensuring a concise and timely display.

### Bot Test
A transfer was made manually and the program detected the transfer operation.
https://stocksharp.com/file/149241
https://stocksharp.com/file/149242
### END:
The provided JavaScript code provides a powerful solution for monitoring recent asset transfers on cryptocurrency exchanges. Its dynamic and real-time nature makes it a valuable tool for traders and developers seeking to understand asset movements between different wallets. This code can be modified and customized to specific needs, providing a solid foundation for those looking to enhance their cryptocurrency trading strategies or develop additional monitoring capabilities.

This article throws some light on the topic and provides a design idea. May your cryptocurrency career be both informative and successful!

From: https://blog.mathquant.c...ocurrency-market-ii.html

An Analysis of Common Requirements Design Examples in the Cryptocurrency Market (I)

2024-03-15T01:17:45Z

In the cryptocurrency asset trading space, obtaining and analyzing market data, querying rates, and monitoring account asset movements are all critical operations. Below are code examples of implementations for some common requirements.

## 1. How do I write the code about getting the currency with the highest increase in 4 hours on Binance Spot?
When writing a quantitative trading strategy program on FMZ platform, the first thing you need to do when you encounter a requirement is to analyze it. So based on the requirements, we analyzed the following contents:

- Which programming language to use?
The plan is to use Javascript to implement it.
- Requires spot real-time quotes in all currencies
The first thing we did when we saw the requirement was to look up Binance API document to find out if there was any aggregated quotes (it's best to have aggregated quotes, it's a lot of work to look up one by one).
We found the aggregated quotes interface: ```GET https://api.binance.com/api/v3/ticker/price```.
On FMZ platform, use the ```HttpQuery``` function to access the exchange ticker interface (public interface that does not require a signature).
- Need to count data for a rolling window period of 4 hours
Conceptualize how to design the structure of the statistical program.
- Calculate price fluctuations and sort them
Thinking about the price fluctuations algorithm, is it: ```price fluctuations (%) = (current price - initial price) / initial price * 100``` in "%".

After figuring out the problem, as well as defining the program. We then got down to the business of designing the program.

### Code Design
```
var dictSymbolsPrice = {}

function main() {
while (true) {
// GET https://api.binance.com/api/v3/ticker/price
try {
var arr = JSON.parse(HttpQuery("https://api.binance.com/api/v3/ticker/price"))
if (!Array.isArray(arr)) {
Sleep(5000)
continue
}

var ts = new Date().getTime()
for (var i = 0; i < arr.length; i++) {
var symbolPriceInfo = arr[i]
var symbol = symbolPriceInfo.symbol
var price = symbolPriceInfo.price

if (typeof(dictSymbolsPrice[symbol]) == "undefined") {
dictSymbolsPrice[symbol] = {name: symbol, data: []}
}
dictSymbolsPrice[symbol].data.push({ts: ts, price: price})
}
} catch(e) {
Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}

// Calculate price fluctuations
var tbl = {
type : "table",
title : "Price fluctuations",
cols : ["trading pair", "current price", "price 4 hours ago", "price fluctuations", "data length", "earliest data time", "latest data time"],
rows : []
}
for (var symbol in dictSymbolsPrice) {
var data = dictSymbolsPrice[symbol].data
if (data[data.length - 1].ts - data[0].ts > 1000 * 60 * 60 * 4) {
dictSymbolsPrice[symbol].data.shift()
}

data = dictSymbolsPrice[symbol].data
dictSymbolsPrice[symbol].percentageChange = (data[data.length - 1].price - data[0].price) / data[0].price * 100
}

var entries = Object.entries(dictSymbolsPrice)
entries.sort((a, b) => b[1].percentageChange - a[1].percentageChange)

for (var i = 0; i < entries.length; i++) {
if (i > 9) {
break
}
var name = entries[i][1].name
var data = entries[i][1].data
var percentageChange = entries[i][1].percentageChange
var currPrice = data[data.length - 1].price
var currTs = _D(data[data.length - 1].ts)
var prePrice = data[0].price
var preTs = _D(data[0].ts)
var dataLen = data.length

tbl.rows.push([name, currPrice, prePrice, percentageChange + "%", dataLen, preTs, currTs])
}

LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(5000)
}
}
```
### Code Analysis
- 1. Data structure
```var dictSymbolsPrice = {}```: An empty object to store price information for each trading pair. The key is the symbol of the trading pair, and the value is an object containing the name of the trading pair, an array of price data, and information about the price fluctuations.
- 2. Main function main()
2.1. Infinite loop
```
while (true) {
// ...
}
```
The program continuously monitors the Binance API trading pair prices through an infinite loop.

2.2. Get price information
```
var arr = JSON.parse(HttpQuery("https://api.binance.com/api/v3/ticker/price"))
```
Get the current price information of the trading pair via Binance API. If the return is not an array, wait for 5 seconds and retry.

2.3. Update price data
```
for (var i = 0; i < arr.length; i++) {
// ...
}
```
Iterate through the array of obtained price information and update the data in dictSymbolsPrice. For each trading pair, add the current timestamp and price to the corresponding data array.

2.4. Exception processing
```
} catch(e) {
Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}
```
Catch exceptions and log the exception information to ensure that the program can continue to execute.

2.5. Calculate the price fluctuations
```
for (var symbol in dictSymbolsPrice) {
// ...
}
```
Iterate through dictSymbolsPrice, calculate the price fluctuations of each trading pair, and remove the earliest data if it is longer than 4 hours.

2.6. Sort and generate tables
```
var entries = Object.entries(dictSymbolsPrice)
entries.sort((a, b) => b[1].percentageChange - a[1].percentageChange)

for (var i = 0; i < entries.length; i++) {
// ...
}
```
Sort the trading pairs in descending order of their price fluctuations and generate a table containing information about the trading pairs.

2.7. Log output and delay
```
LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(5000)
```
Output the table and the current time in the form of a log and wait for 5 seconds to continue the next round of the loop.

The program obtains the real-time price information of the trading pair through Binance API, then calculates the price fluctuations, and outputs it to the log in the form of a table. The program is executed in a continuous loop to realize the function of real-time monitoring of the prices of trading pairs. Note that the program includes exception processing to ensure that the execution is not interrupted by exceptions when obtaining price information.

### Live Trading Running Test
https://stocksharp.com/file/149238
Since data can only be collected bit by bit at the beginning, it is not possible to calculate the price fluctuations on a rolling basis without collecting enough data for a 4-hour window. Therefore, the initial price is used as the base for calculation, and after collecting enough data for 4 hours, the oldest data will be eliminated in order to maintain the 4-hour window for calculating the price fluctuations.

## 2. Check the full variety of funding rates for Binance U-denominated contracts
Checking the funding rate is similar to the above code, first of all, we need to check the Binance API documentation to find the funding rate related interface. Binance has several interfaces that allow us to query the rate of funds, here we take the interface of the U-denominated contract as an example:

```
GET https://fapi.binance.com/fapi/v1/premiumIndex
```
### Code Implementation
Since there are so many contracts, we're exporting the top 10 largest funding rates here.

```
function main() {
while (true) {
// GET https://fapi.binance.com/fapi/v1/premiumIndex
try {
var arr = JSON.parse(HttpQuery("https://fapi.binance.com/fapi/v1/premiumIndex"))
if (!Array.isArray(arr)) {
Sleep(5000)
continue
}

arr.sort((a, b) => parseFloat(b.lastFundingRate) - parseFloat(a.lastFundingRate))
var tbl = {
type: "table",
title: "Top 10 funding rates for U-denominated contracts",
cols: ["contracts", "funding rate", "marked price", "index price", "current rate time", "next rate time"],
rows: []
}
for (var i = 0; i < 9; i++) {
var obj = arr[i]
tbl.rows.push([obj.symbol, obj.lastFundingRate, obj.markPrice, obj.indexPrice, _D(obj.time), _D(obj.nextFundingTime)])
}
LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
} catch(e) {
Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}
Sleep(1000 * 10)
}
}
```
The returned data structure is as follows, and check the Binance documentation, it shows that lastFundingRate is the funding rate we want.

```
{
"symbol":"STMXUSDT",
"markPrice":"0.00883606",
"indexPrice":"0.00883074",
"estimatedSettlePrice":"0.00876933",
"lastFundingRate":"0.00026573",
"interestRate":"0.00005000",
"nextFundingTime":1702828800000,
"time":1702816229000
}
```
Live trading running test:
https://stocksharp.com/file/149239
### Getting OKX exchange contract funding rates of Python version
A user has asked for a Python version of the example, and it's for the OKX exchange. Here is an example:

The data returned by the interface ```https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1```:
```
{
"code":"0",
"data":[
{
"fundingTime":1702828800000,
"fundingList":[
{
"instId":"BTC-USDT-SWAP",
"nextFundingRate":"0.0001102188733642",
"minFundingRate":"-0.00375",
"fundingRate":"0.0000821861465884",
"maxFundingRate":"0.00375"
} ...
```
Specific code:

```
import requests
import json
from time import sleep
from datetime import datetime

def main():
while True:
# https://www.okx.com/pria...rate-all?currencyType=1
try:
response = requests.get("https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1")
arr = response.json()["data"][0]["fundingList"]
Log(arr)
if not isinstance(arr, list):
sleep(5)
continue

arr.sort(key=lambda x: float(x["fundingRate"]), reverse=True)

tbl = {
"type": "table",
"title": "Top 10 funding rates for U-denominated contracts",
"cols": ["contracts", "next rate", "minimum", "current", "maximum"],
"rows": []
}

for i in range(min(9, len(arr))):
obj = arr[i]
row = [
obj["instId"],
obj["nextFundingRate"],
obj["minFundingRate"],
obj["fundingRate"],
obj["maxFundingRate"]
]
tbl["rows"].append(row)

LogStatus(_D(), "\n", '`' + json.dumps(tbl) + '`')

except Exception as e:
Log(f"Error: {str(e)}")

sleep(10)
```
Live trading running test:
https://stocksharp.com/file/149240
### END
These examples provide basic design ideas and calling methods, the actual project may need to make appropriate changes and extensions based on the specific needs. Hopefully, these codes can help you better meet the various needs in cryptocurrency digital asset trading.
From: https://blog.mathquant.c...tocurrency-market-i.html

The Crucial Role of Efficient Quantitative Data Exploration Tools in Boosting Trading Success

2024-03-14T09:21:47Z

In today's fiercely competitive financial market, quantitative trading, as a trading strategy based on data analysis and algorithmic models, is becoming an increasingly favored choice for investors and traders. In the field of quantitative trading, the value of data is becoming increasingly prominent. Therefore, an efficient and reliable quantitative data exploration tool has become an indispensable key to achieving successful transactions.

In this era where data-driven decision-making is increasingly valued, the FMZ Quant data exploration module has emerged. As one of the essential tools in the field of quantitative trading, it is not only an ordinary data analysis software, but also a revolutionary innovation that provides investors with unique data analysis and mining functions, helping them seize opportunities and reduce risks in complex and ever-changing financial markets.

FMZ Quant, as a professional quantitative trading platform, is supported by numerous quantitative trading tools. At present, the "Data Exploration" module of the FMZ Quant Trading Platform has integrated the services of the datadata platform, giving users more advantages in multidimensional data analysis, mining visual data, exploring trading strategies, and other aspects. FMZ's self-developed datadata platform is a quantitative financial data platform. Using SQL queries to analyze massive amounts of data and configuring them through visual interfaces, generating various charts suitable for data analysis and sharing them with the team, allowing us to easily grasp market trends and seize investment opportunities!

FMZ Quant Data Exploration Module
First of all, let's familiarize with the FMZ Quant Data Exploration module, which is used just like on datadata. For each FMZ platform user, we don't need to register for the datadata platform again, and we can use all the features of the datadata platform directly.
https://stocksharp.com/file/149179
Data areas
The list on the left side shows the data content that has been supported on-line, currently supporting K-line data (OHLC) and Tick data of each exchange (platform). More types and dimensions of data will be supported in the future.
These data are updated continuously in real time, allowing us to always grasp the market dynamics.
For example, if we select OHLC and then select market->bitfinex_m1, we can see the field names in this table object after clicking Expand.
https://stocksharp.com/file/149180
Click on the table chart to preview some of the data.

The platform also supports uploading your own data by clicking the "Upload Data" button at the bottom of the list.

Uploading CSV files from your device to the server.
The file size should not exceed 10 MB, with a maximum of 10,000 rows and 128 columns.

SQL statement edit area
https://stocksharp.com/file/149181
Here is the edit box for writing a specific query statement, we will show two interesting examples later, let's understand the other features first.
https://stocksharp.com/file/149182
There are two control buttons here, the first one can be used to format the SQL statement easily. The second button is used to insert variables used in the SQL statement, similar to adding a parameter to the SQL query that can be modified in real time (without having to hard-code some of the query conditions into the SQL statement). For example:
https://stocksharp.com/file/149183
Input '1inch_usd' into the parameter test and click the "Execute" button on the right side, then you can query all the data of the variety 1inch_usd. The queried data can also be exported and downloaded locally:
https://stocksharp.com/file/149184
It supports JSON, CSV format.

If we want to save the SQL query, we can click the "Save" button in the upper right corner to record the SQL query in the resource list of the current FMZ account's "Data Exploration" (the resource list button is on the left side of the save button) for future use.

At present, the interface we see is simple and the functions are simple, but in practical use, we will experience the powerful use of this tool. Next, let's take a look at two more complex examples.

Volatility ranking
```
SELECT
UPPER(REPLACE(symbol, '_usdt.swap', '')) as symbol,
((MAX(high) - MIN(low)) / AVG((high + low) / 2)) AS volatility_percentage
FROM
market.futures_binance_d1
WHERE
timestamp >= CURRENT_DATE - INTERVAL '{{days}} day' and symbol like '%.swap'
GROUP BY
symbol
ORDER BY
volatility_percentage {{rank}}
LIMIT
{{limit}};
```
This SQL code is used to get the volatility percentage of the trading pair that meets the criteria from the table "market.futures_binance_d1" and sort and limit the quantity output by volatility percentage.

The explanation of this SQL is given below:

```
1. Two expressions were used for calculation, one was to replace the '_usdt.swap' in the 'symbol' column with an empty string and convert the result to uppercase, and the other was to calculate (MAX(high) - MIN(low)) / AVG((high+low) / 2).
The first expression uses the REPLACE function to replace strings that meet the criteria, and then uses the UPPER function to convert the result to uppercase.
The second expression calculates the difference between the highest and lowest prices divided by the average of the highest and lowest prices to calculate the percentage of volatility.

2. FROM clause:
The specified data table to be queried is "market.futures.binance_d1".

3. WHERE clause:
Two filter conditions are used: timestamp >= CURRENT_DATE - INTERVAL '{{days}} day' and symbol like '%.swap'.
The first condition filters out data within the last {{days}} days.
The second condition filters out trading pairs where the "symbol" column ends in '.swap'.

4. GROUP BY clause:
Group by the "symbol" column.

5. ORDER BY clause:
Sort by volatility percentage, either ascending (ASC) or descending (DESC), depending on the {{rank}} parameter.

6. LIMIT clause:
Limit the number of output results, which can be set according to the {{limit}} parameter.
```
https://stocksharp.com/file/149185
When we enter the parameters:
days: 10 , rank: DESC , limit: 10, click the "Execute" button to execute the SQL statement and query the result.

In addition to displaying data in the form of tables, it can also be displayed in a variety of visualization ways. After setting up some relevant settings for visualization, the data will be displayed in a richer and more vivid way.
https://stocksharp.com/file/149186
The created query can also generate URLs for easy sharing, and we can also modify the parameters to update the query (try modifying the parameters to update the query here in the article). Follwing is a chart of the real-time data generated:

volatility ranking
https://stocksharp.com/file/149187
In-depth Replay
Next we're going to study an example of studying a market micro-scenario, which is a wonderful tool for studying the details of high-frequency trading.

```
select * from market.binance where symbol = lower('{{symbol}}') order by timestamp desc limit 2000
```
Use the above SQL statement to query the tick level tick data for a particular species.
https://stocksharp.com/file/149188
The SQL query for this example is very simple, just querying the Tick data for a certain variety (specified by the parameter symbol) on the Binance exchange.

The point is to show the data in the form of a live trading replay, on a time series, with multiple charts:
https://stocksharp.com/file/149189
Is it convenient to study the details in the market?

Next, let's take a look at how to share our research. We can click on the share icon in the upper right corner.
https://stocksharp.com/file/149190
These shared codes, links, can be embedded in FMZ platform community posts, articles. They can be embedded in web pages and can be republished in other communities, forums, etc. It can also be shared directly to anyone.
https://stocksharp.com/file/149191
What are you waiting for with this powerful quantitative trading tool? Try to mine the data and analyze it.
From: https://blog.mathquant.c...-exploration-module.html

Custom Local Broker Api

2023-12-03T16:11:47Z

Hi, I have to acces to my broker api with my api key and password. I have also all endpoints and requirements such as headers and payloads in api user guide’s document. How can I create new connector or adaptor in S#?

Google Feed

2018-04-06T05:06:09Z

I am having problems to do the setup of the Google on Hydra. Where can I find some tutorial about it?

After I select the security and select to show the candles like show in this video https://www.youtube.com/watch?v=3F8WvQq_O_E, I receive the message "No data"

Custom Adapter

2021-02-23T09:43:07Z

Hi,

I try to configure my custom created connector by using ConnectorWindow in StockSharp.Xaml.
But I cannot find it in the list of connectors.
I put my dll in the same folder as exe and I also added attributes like DisplayNameLoc, CategoryLoc, DescriptionLoc and MessageAdapterCategory.
So I wonder if it is possible or did I do it wrong.
If not, how can I use my custom connector to work with other product like S# Designer?

Thanks

Unable to connect to exchange

2023-08-12T02:46:21Z

I just registered with StockSharp and installed the Terminal. I am trying to connect to Binance but it gives me an error - Connector is stub only.
I believe that one connection is allowed for the free tier, right? I remember selecting Binance when prompted for the 1 free connection during the installation.

Does Ecng.ManagedWinapi support MAUI?

2023-07-15T09:02:11Z

https://stackoverflow.co...ui-windows-using-winapi like this article said , support MAUI.

S#.Designer syllabus.

2019-05-16T23:12:23Z

All video-lessons are available via the links below.
All samples for lessons can be installed via S#.Installer.
For Basic course you need the packet: Edu Designer Basic
For Advanced course you need the packet: Edu Designer Advanced

Basic course.

1. S#.Designer basics
The lesson covers:
- Installing the program
- Configuring the interface of the program windows
- Examines the main sections of the Program menu
- Examines the sections of the strategy tree
- Shows how to download instruments and market data for the first time
- Shows how to start testing a strategy on the built-in SMA strategy.

(The new version of the designer, like all programs, is installed through the Installer program.
The fifth version of the designer lacks the ability to select the themes of the designer, which was present in the fourth version)

2. Visual editor and strategy designer blocks - 1.

The lesson covers:
- General description of strategy cubes
- Examines the sections of the strategy cubes menu
- Examines the cube chart panel
- Examines the construction of candlestick charts
- Examines the construction of charts of the SMA and Bollinger indicator in the same window and in different windows

(In the fifth version of the program, the location of some cubes in the menu has changed.
In the fifth version, the mathematics section is replaced by a formula cube.)

3. Visual editor and strategy designer blocks - 2.

The lesson covers:
- Description of the cube Variable and examines examples of the use of the cube
- Examines the Logic cube and an example of its application
- Examines the Previous value cube and an example of its application
- Examines the Mathematics section and the use of cubes that are included in it
- Examines the Converters section (cubes "Indexer" and "Converter") and an example of sharing the cubes of the section
- Considers the cube "Opening a position"
- Considers the cube "Position" and the scheme in which it is applied
- Considers the cube "Comparison" and an example of its application
- Considered building a simple strategy:
If the closing price of the previous candle is less than the closing price of the current one, then we buy, if not, we sell.
- Considers the "Comparison" cube and an example of its application

(In the fifth version, the mathematics section is replaced by one formula cube. In the fifth version of the program, the "Position opening" cube is replaced with "Position registration")

4. Work with the strategy scheme.

The lesson covers:
- Debugger tools
- Working with breakpoints is considered on the example of a circuit
- On an example, the possibility of imposing additional conditions on triggering a breakpoints is considered

5. Visual editor and strategy designer blocks - 3.

The lesson covers:
- Considers the cube "Position protection"
- A strategy is built using the "Position protection" cube:
If the difference between the closing price and the opening price of the candle is greater than 1, then we buy.
We sell position protection through the cube, provided that:
Take Profit - the price increases by 2%
Stop Loss - the price decreases by 3%
- An example of constructing the conditions for triggering transactions has been analyzed, in which Buy and Sell transactions go sequentially one after the other (the simplest flag)
- A scheme has been built for obtaining the absolute value of a position and doubling its value
- Using the example of the scheme from lesson three and the scheme for obtaining the absolute value of the position, the following scheme is obtained:
If the closing price of the previous candle is less than the closing price of the current one, then we buy, if, on the contrary, we sell.
If the position is not equal to zero, then the trade is carried out with a double volume

6. Visual editor and strategy designer blocks - 4.

The lesson covers:
- Examines the cubes of the "Mathematics" section - formulas, including examples of their use
- Considered the construction of the scheme:
If the closing price of the previous candle is greater than the value of the SMA indicator for 20 periods plus 3 standard deviations for 20 periods, then we sell by candle open price.
If the closing price of the previous candle is less than the value of the SMA indicator for 20 periods minus 3 standard deviations for 20 periods, then we make a buy at the opening price of the candle.

(In the fifth version of the program there is no section "Mathematics", all the cubes of this section used in earlier versions of the program are replaced by one cube formula.
In the fifth version of the program, the cube "Position opening" is replaced by the cube "Order registration".)

7. More strategies.

The lesson covers:
- The construction of a diagram based on the Bollinger indicator is considered:
If the candlestick crosses the upper curve of the Bollinger indicator, then we buy.
If the candlestick crosses the lower curve of the Bollinger indicator then we sell.

- Considered the construction of the scheme based on the MACD indicator:
If the MACD curve changes its sign from minus to plus, then buy.
If the MACD curve changes its sign from plus to minus, then we sell.

- Considered a visual comparison of the results of two strategies
- Considered exporting test results to a file for subsequent analysis

8. Visual editor and strategy designer blocks - 5.

The lesson covers:
- The construction of a scheme using candles of different TFs is considered:
First branch: The strategy will buy if the closing price of a five-minute candle is greater than the maximum of 20 previous days.
The strategy will sell if the closing price of the 5 minute candle is less than the previous 10 day low.

The second branch: The strategy will sell if the closing price of the five-minute candle is less than the minimum of the previous 20 days.
The strategy will buy if the closing price of the five-minute candle is greater than the high of the previous 10 days.

(In the fifth version of the designer, the appearance of the flag cube was changed. Also, in the fifth version of the designer, the strategy was changed in terms of the appearance of 2 sell cubes and 2 buy cubes, due to a different principle of receiving a signal to the trigger.)

9. Time Cubes.

The lesson covers:
- Considered the "Working time" cube
- Considered the "Variable" cube with the "Strategy" value
- Considered the "Converter" cube with the function of getting time
- Considered the strategy of working with the "Working time" cube with the condition:
Strategy buys a minute before the end working time.
- Considered an example of working with the "Working hours" cube:
The strategy buys at 18.00.
- Considered a 7th lesson strategy with additional conditions:
The strategy closes a position 5 minutes before the end of working hours.

(In the fifth version of the designer, for correct work with the formula that calculates the time and the cube "Working time", after importing the strategies, it is recommended to recreate them)

10. Working with market data. S#.Data (Hydra)

The lesson covers:
- Considered examples of choosing a market data store
- Considered an example of working with the S#.Data (Hydra) program
- Considered a server mode of working with S#.Data (Hydra) program
- Considered an example of using a market data transmitted through a server mode

(In the fifth server-mode version does not contain WCF mode.)

11. Backtest and optimization.

The lesson covers:
- Considered the basics of strategy optimization
- Considered strategy optimization based on changing the indicator parameter used in the strategy
- Considered the principle of portfolio optimization of a strategy on various instruments

12. Live trading.

The lesson covers:
-Example of setting up a strategy for connecting to Live mode

Advanced course.

13. Composite Cubes.

The lesson covers:
- Considered the "Union" cube
- Considered the principle of working with a compound cube using the example of creating a cube for closing a position
- Considered an example of introducing a compound cube "Closing a position" into an existing strategy from lesson 9

14. Creating candles from ticks.

The lesson covers:
- Considered how to download ticks in the program
- Considered how to build candles from the "Depth of Market"
- Considered the modes "Build", "Downloads", "Load and build" candles
- Considered an example of building volume candles
- Considered an example of plotting a Range of candles
- Considered construction of candles from Ticks
- Considered the construction of candles from candles of a smaller TF
- Considered the use of candles built in the S#.Data (Hydra)
- Considered building a volume profile

15. Building the Flag component cube

16. Strategy based on finding the price of the maximum volume.

The lesson covers:
- Considered the function of the "Converter" cube. Maximum volume
- A strategy has been built in which candlestick data is built from ticks, with the following conditions:
The strategy buys if the closing price is higher than the opening price of the candle.
The strategy sells at the sixth candlestick.

(In the fifth version, the Flag cube was changed, as well as the condition for raising the flag. In the fifth version, the formula block cubes were replaced with the formula cube.)

17. Indices and multiple security strategies - 1.

The lesson covers:
- Considered working with stock indices
- Considered working with futures on the example of a strategy with conditions:
If the index calculated by the SBER @ TQBR / SRM9 @ FORTS formula is less than the average value for 10 periods, then Sberbank shares are sold.
If the index calculated by the SBER @ TQBR / SRM9 @ FORTS formula is greater than the average value for 10 periods, then we buy Sberbank shares.
- The function of constructing a continuous futures is considered
- A strategy with a continuous futures is built with the condition:
If the current value of the SBER @ TQBR / SBER_СF @ FORTS index is 0.005 units above the average, sell the instrument Sberbank Shares and buy the instrument of Sberbank shares.
If the current value of the SBER @ TQBR / SBER_СF @ FORTS index is 0.005 units lower than the average, buy the Sberbank Shares instrument and sell the Sberbank shares instrument.
- Based on the strategy, an example of building a scheme with cancellation of an order is considered

18. Indices and multiple security strategies - 2.

The lesson covers:
- Considered a pair trading strategy based on the previous strategy.
If the index calculated by the SBER @ TQBR / GAZP @ TQBR formula grows, then we buy a cheaper asset and sell a more expensive one.
If the index calculated using the SBER @ TQBR / GAZP @ TQBR formula decreases, then we buy a more expensive asset and sell a cheaper one.
- Considered the round operator - to get an integer value

19. Indices and multiple security strategies - 3.

Lesson highlights:
- Considered a pyramiding strategy based on the previous strategy from the previous lesson.

20. Working with the editor of the program code-1.

The lesson covers:
- Considered the "Source Code" cube
- Considered the principle of creating a cube with a code
- Considered the principle of creating your own unique cube with a code

(Today the StockSharp website does not have a direct link to Github, so you need to go to it not through the website)

21. Work with the program code editor - 2.

The lesson covers:
- Considered the creation of cubes on C# in Visual Studio
- Considered the DLL cube
- Considered the principle of working with S#.API libraries in Visual Studio

22. Export and import of strategies in the program.

You can buy any course right now from our site