Community. StockSharp

Mastering Uniswap V3: Advanced Strategies for Exchange Pool Liquidity (Part 1)

2024-03-26T09:17:00Z

NonfungiblePositionManager Contract in Uniswap V3

When we add liquidity to the Uniswap V3 liquidity pool (trading pair pool), the NonfungiblePositionManager contract returns a minted NFT to us as proof of the liquidity addition.

The first step is to use the router contract to get the address of the corresponding NonfungiblePositionManager contract, and then use the balanceOf method of the NonfungiblePositionManager contract to get the number of position NFTs for the specified wallet address.

Then use the tokenOfOwnerByIndex method to get the tokenId of these position NFTs, with these tokenId, you can use the positions method to continue to query the specific details of these positions.

The following test code:

```
// Uniswap ABI
const ABI_UniswapV3Router = `[{"inputs":[{"internalType":"address","name":"_factoryV2","type":"address"},{"internalType":"address","name":"factoryV3","type":"address"},{"internalType":"address","name":"_positionManager","type":"address"},{"internalType":"address","name":"_WETH9","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"WETH9","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveMax","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveMaxMinusOne","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveZeroThenMax","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveZeroThenMaxMinusOne","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"callPositionManager","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"paths","type":"bytes[]"},{"internalType":"uint128[]","name":"amounts","type":"uint128[]"},{"internalType":"uint24","name":"maximumTickDivergence","type":"uint24"},{"internalType":"uint32","name":"secondsAgo","type":"uint32"}],"name":"checkOracleSlippage","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint24","name":"maximumTickDivergence","type":"uint24"},{"internalType":"uint32","name":"secondsAgo","type":"uint32"}],"name":"checkOracleSlippage","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactInputParams","name":"params","type":"tuple"}],"name":"exactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct IV3SwapRouter.ExactInputSingleParams","name":"params","type":"tuple"}],"name":"exactInputSingle","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct IV3SwapRouter.ExactOutputSingleParams","name":"params","type":"tuple"}],"name":"exactOutputSingle","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factoryV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getApprovalType","outputs":[{"internalType":"enum IApproveAndCall.ApprovalType","name":"","type":"uint8"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"}],"internalType":"struct IApproveAndCall.IncreaseLiquidityParams","name":"params","type":"tuple"}],"name":"increaseLiquidity","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"internalType":"struct IApproveAndCall.MintParams","name":"params","type":"tuple"}],"name":"mint","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"previousBlockhash","type":"bytes32"},{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"positionManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"pull","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"refundETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowed","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowedIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"}],"name":"swapExactTokensForTokens","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMax","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"}],"name":"swapTokensForExactTokens","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"sweepToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"}],"name":"sweepToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"sweepTokenWithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"sweepTokenWithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"unwrapWETH9","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"}],"name":"unwrapWETH9","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"unwrapWETH9WithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"unwrapWETH9WithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"wrapETH","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]`
const ABI_NonfungiblePositionManager = `[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_WETH9","type":"address"},{"internalType":"address","name":"_tokenDescriptor_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"Collect","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint128","name":"liquidity","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"DecreaseLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint128","name":"liquidity","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"IncreaseLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH9","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint128","name":"amount0Max","type":"uint128"},{"internalType":"uint128","name":"amount1Max","type":"uint128"}],"internalType":"struct INonfungiblePositionManager.CollectParams","name":"params","type":"tuple"}],"name":"collect","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint160","name":"sqrtPriceX96","type":"uint160"}],"name":"createAndInitializePoolIfNecessary","outputs":[{"internalType":"address","name":"pool","type":"address"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct INonfungiblePositionManager.DecreaseLiquidityParams","name":"params","type":"tuple"}],"name":"decreaseLiquidity","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount0Desired","type":"uint256"},{"internalType":"uint256","name":"amount1Desired","type":"uint256"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct INonfungiblePositionManager.IncreaseLiquidityParams","name":"params","type":"tuple"}],"name":"increaseLiquidity","outputs":[{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint256","name":"amount0Desired","type":"uint256"},{"internalType":"uint256","name":"amount1Desired","type":"uint256"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct INonfungiblePositionManager.MintParams","name":"params","type":"tuple"}],"name":"mint","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"positions","outputs":[{"internalType":"uint96","name":"nonce","type":"uint96"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"feeGrowthInside0LastX128","type":"uint256"},{"internalType":"uint256","name":"feeGrowthInside1LastX128","type":"uint256"},{"internalType":"uint128","name":"tokensOwed0","type":"uint128"},{"internalType":"uint128","name":"tokensOwed1","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refundETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowed","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowedIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"sweepToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount0Owed","type":"uint256"},{"internalType":"uint256","name":"amount1Owed","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"uniswapV3MintCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"unwrapWETH9","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]`
const ABI_Pool = '[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"name\":\"Burn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"name\":\"Collect\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"name\":\"CollectProtocol\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"paid0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"paid1\",\"type\":\"uint256\"}],\"name\":\"Flash\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"observationCardinalityNextOld\",\"type\":\"uint16\"},{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"observationCardinalityNextNew\",\"type\":\"uint16\"}],\"name\":\"IncreaseObservationCardinalityNext\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"indexed\":false,\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"}],\"name\":\"Initialize\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"name\":\"Mint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"feeProtocol0Old\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"feeProtocol1Old\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"feeProtocol0New\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"feeProtocol1New\",\"type\":\"uint8\"}],\"name\":\"SetFeeProtocol\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"amount0\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"amount1\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"liquidity\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"}],\"name\":\"Swap\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount0Requested\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1Requested\",\"type\":\"uint128\"}],\"name\":\"collect\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount0Requested\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1Requested\",\"type\":\"uint128\"}],\"name\":\"collectProtocol\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"fee\",\"outputs\":[{\"internalType\":\"uint24\",\"name\":\"\",\"type\":\"uint24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feeGrowthGlobal0X128\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feeGrowthGlobal1X128\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"flash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"observationCardinalityNext\",\"type\":\"uint16\"}],\"name\":\"increaseObservationCardinalityNext\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"liquidity\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxLiquidityPerTick\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"observations\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"blockTimestamp\",\"type\":\"uint32\"},{\"internalType\":\"int56\",\"name\":\"tickCumulative\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityCumulativeX128\",\"type\":\"uint160\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32[]\",\"name\":\"secondsAgos\",\"type\":\"uint32[]\"}],\"name\":\"observe\",\"outputs\":[{\"internalType\":\"int56[]\",\"name\":\"tickCumulatives\",\"type\":\"int56[]\"},{\"internalType\":\"uint160[]\",\"name\":\"secondsPerLiquidityCumulativeX128s\",\"type\":\"uint160[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"positions\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"liquidity\",\"type\":\"uint128\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthInside0LastX128\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthInside1LastX128\",\"type\":\"uint256\"},{\"internalType\":\"uint128\",\"name\":\"tokensOwed0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"tokensOwed1\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"protocolFees\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"token0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"token1\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"feeProtocol0\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"feeProtocol1\",\"type\":\"uint8\"}],\"name\":\"setFeeProtocol\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"slot0\",\"outputs\":[{\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"},{\"internalType\":\"uint16\",\"name\":\"observationIndex\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"observationCardinality\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"observationCardinalityNext\",\"type\":\"uint16\"},{\"internalType\":\"uint8\",\"name\":\"feeProtocol\",\"type\":\"uint8\"},{\"internalType\":\"bool\",\"name\":\"unlocked\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"}],\"name\":\"snapshotCumulativesInside\",\"outputs\":[{\"internalType\":\"int56\",\"name\":\"tickCumulativeInside\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityInsideX128\",\"type\":\"uint160\"},{\"internalType\":\"uint32\",\"name\":\"secondsInside\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"zeroForOne\",\"type\":\"bool\"},{\"internalType\":\"int256\",\"name\":\"amountSpecified\",\"type\":\"int256\"},{\"internalType\":\"uint160\",\"name\":\"sqrtPriceLimitX96\",\"type\":\"uint160\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"swap\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"amount0\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1\",\"type\":\"int256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int16\",\"name\":\"\",\"type\":\"int16\"}],\"name\":\"tickBitmap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tickSpacing\",\"outputs\":[{\"internalType\":\"int24\",\"name\":\"\",\"type\":\"int24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"\",\"type\":\"int24\"}],\"name\":\"ticks\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"liquidityGross\",\"type\":\"uint128\"},{\"internalType\":\"int128\",\"name\":\"liquidityNet\",\"type\":\"int128\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthOutside0X128\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthOutside1X128\",\"type\":\"uint256\"},{\"internalType\":\"int56\",\"name\":\"tickCumulativeOutside\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityOutsideX128\",\"type\":\"uint160\"},{\"internalType\":\"uint32\",\"name\":\"secondsOutside\",\"type\":\"uint32\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token0\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token1\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]'
const ABI_Factory = '[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickSpacing\",\"type\":\"int24\"}],\"name\":\"FeeAmountEnabled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnerChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token0\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token1\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"},{\"indexed\":false,\"internalType\":\"int24\",\"name\":\"tickSpacing\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"pool\",\"type\":\"address\"}],\"name\":\"PoolCreated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"},{\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"}],\"name\":\"createPool\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pool\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"},{\"internalType\":\"int24\",\"name\":\"tickSpacing\",\"type\":\"int24\"}],\"name\":\"enableFeeAmount\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint24\",\"name\":\"\",\"type\":\"uint24\"}],\"name\":\"feeAmountTickSpacing\",\"outputs\":[{\"internalType\":\"int24\",\"name\":\"\",\"type\":\"int24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint24\",\"name\":\"\",\"type\":\"uint24\"}],\"name\":\"getPool\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parameters\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token0\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token1\",\"type\":\"address\"},{\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"},{\"internalType\":\"int24\",\"name\":\"tickSpacing\",\"type\":\"int24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]'

// Uniswap contract address
const UniswapV3RouterAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
const ContractV3Factory = "0x1F98431c8aD98523631AE4a59f267346ea31F984"

// common constant
const TWO = BigInt(2)
const Q192 = (TWO ** BigInt(96)) ** TWO
const Q96 = (TWO ** BigInt(96))

// Convert to readable amount
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}

// Reverse conversion from readable amount to amount used for passing parameters and calculations
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}

function main(){
// The address of the wallet to be searched
// const walletAddress = exchange.IO("address")
const walletAddress = "0x28df8b987BE232bA33FdFB8Fc5058C1592A3db26"

// Get the address of Uniswap V3's positionManager contract
exchange.IO("abi", UniswapV3RouterAddress, ABI_UniswapV3Router)
const NonfungiblePositionManagerAddress = exchange.IO("api", UniswapV3RouterAddress, "positionManager")
Log("NonfungiblePositionManagerAddress:", NonfungiblePositionManagerAddress)

// Register ABI for positionManager contracts
exchange.IO("abi", NonfungiblePositionManagerAddress, ABI_NonfungiblePositionManager)

// Query the number of Uniswap V3 positions NFT owned by the current account
var nftBalance = exchange.IO("api", NonfungiblePositionManagerAddress, "balanceOf", walletAddress)
Log("nftBalance:", nftBalance)

// Query the TokenId of these NFTs
var nftTokenIds = []
for (var i = 0 ; i < nftBalance; i++) {
var nftTokenId = exchange.IO("api", NonfungiblePositionManagerAddress, "tokenOfOwnerByIndex", walletAddress, i)
nftTokenIds.push(nftTokenId)
Log("nftTokenId:", nftTokenId)
}

// Query liquidity position details based on the tokenId of the positions NFT
var positions = []
for (var i = 0; i < nftTokenIds.length; i++) {
var pos = exchange.IO("api", NonfungiblePositionManagerAddress, "positions", nftTokenIds[i])
Log("pos:", pos)

// Parsing position data
positions.push(parsePosData(pos))
}

var tbl = {
type : "table",
title : "LP",
cols : ["range(token0 valuation)", "token0", "token1", "fee", "lowerPrice(tickLower)", "upperPrice(tickUpper)", "liquidity", "amount0", "amount1"],
rows : positions
}
LogStatus("`" + JSON.stringify(tbl) + "`")
}

// Record information about tokens queried through coingecko.com
var tokens = []
function init() {
// When initializing, get information about all tokens to query the
var res = JSON.parse(HttpQuery("https://tokens.coingecko.com/uniswap/all.json"))
Log("fetch", res.tokens.length, "tokens from", res.name)
_.each(res.tokens, function(token) {
tokens.push({
name : token.name,
symbol : token.symbol,
decimals : token.decimals,
address : token.address
})
})
Log("tokens:", tokens)
}

function parsePosData(posData) {
/*
{
"nonce": "0",
"operator": "0x0000000000000000000000000000000000000000",
"token1": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
"fee": "3000",
"feeGrowthInside0LastX128": "552824104363438506727784685971981736468",
"feeGrowthInside1LastX128": "2419576808699564757520565912733367379",
"tokensOwed0": "0",
"tokensOwed1": "0",
"token0": "0x1f9840a85d5af5bf1d1762f925bdaddc4201f984",
"tickLower": "-62160",
"tickUpper": "-41280",
"liquidity": "19090316141441365693"
}
*/

var token0Symbol = null
var token1Symbol = null
// Determine the token according to the address of the token, record the information about the token
for (var i in tokens) {
if (tokens[i].address.toLowerCase() == posData.token0.toLowerCase()) {
token0Symbol = tokens[i]
} else if (tokens[i].address.toLowerCase() == posData.token1.toLowerCase()) {
token1Symbol = tokens[i]
}
}

if (!token0Symbol || !token1Symbol) {
Log("token0Symbol:", token0Symbol, ", token1Symbol:", token1Symbol)
throw "token not found"
}

// get Pool , obtaining data about the exchange pool
var poolInfo = getPool(token0Symbol.address, token1Symbol.address, posData.fee)
Log("poolInfo:", poolInfo)
/* Data examples
{
"slot0":{
"sqrtPriceX96":"4403124416947951698847768103","tick":"-57804","observationIndex":136,"observationCardinality":300,
"observationCardinalityNext":300,"feeProtocol":0,"unlocked":true
}
}
*/

// Calculate token0Amount, token1Amount
var currentTick = parseInt(poolInfo.slot0.tick)
var lowerPrice = 1.0001 ** posData.tickLower
var upperPrice = 1.0001 ** posData.tickUpper
var sqrtRatioA = Math.sqrt(lowerPrice)
var sqrtRatioB = Math.sqrt(upperPrice)
var sqrtPrice = Number(BigFloat(poolInfo.slot0.sqrtPriceX96) / Q96)

var amount0wei = 0
var amount1wei = 0
if (currentTick <= posData.tickLower) {
amount0wei = Math.floor(posData.liquidity * ((sqrtRatioB - sqrtRatioA) / (sqrtRatioA * sqrtRatioB)))
} else if (currentTick > posData.tickUpper) {
amount1wei = Math.floor(posData.liquidity * (sqrtRatioB - sqrtRatioA))
} else if (currentTick >= posData.tickLower && currentTick < posData.tickUpper) {
amount0wei = Math.floor(posData.liquidity * ((sqrtRatioB - sqrtPrice) / (sqrtPrice * sqrtRatioB)))
amount1wei = Math.floor(posData.liquidity * (sqrtPrice - sqrtRatioA))
}

var rangeToken0 = (1.0001 ** -posData.tickUpper) + " ~ " + (1.0001 ** -posData.tickLower)
var amount0 = toAmount(amount0wei, token0Symbol.decimals)
var amount1 = toAmount(amount1wei, token1Symbol.decimals)

return [rangeToken0, token0Symbol.symbol, token1Symbol.symbol, posData.fee / 10000 + "%",
`${lowerPrice}(tickLower:${posData.tickLower})`, `${upperPrice}(tickUpper:${posData.tickUpper})`, posData.liquidity,
amount0, amount1]
}

function getPool(token0Address, token1Address, fee) {
if (BigInt(token0Address) > BigInt(token1Address)) {
var tmp = token0Address
token0Address = token1Address
token1Address = tmp
}

// Calculating the contract address of an exchange pool using Uniswap's factory contract
exchange.IO("abi", ContractV3Factory, ABI_Factory)
var poolAddress = exchange.IO("api", ContractV3Factory, "getPool", token0Address, token1Address, fee)
if (!poolAddress) {
throw "getPool failed"
}

// ABI for registered pool contracts
exchange.IO("abi", poolAddress, ABI_Pool)

// Call the pool contract's slot0 method to query the current exchange pool's data
var slot0 = exchange.IO("api", poolAddress, "slot0")
if (!slot0) {
throw "get slot0 failed"
}

return {
"slot0": slot0
}
}
```

The retrieved liquidity position information (which needs further parsing):

```
{
"nonce": "0",
"operator": "0x0000000000000000000000000000000000000000",
"token1": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
"fee": "3000",
"feeGrowthInside0LastX128": "552824104363438506727784685971981736468",
"feeGrowthInside1LastX128": "2419576808699564757520565912733367379",
"tokensOwed0": "0",
"tokensOwed1": "0",
"token0": "0x1f9840a85d5af5bf1d1762f925bdaddc4201f984",
"tickLower": "-62160",
"tickUpper": "-41280",
"liquidity": "19090316141441365693"
}
```

Parsing Liquidity Holdings for Market Making Ranges

The positions method of Uniswap's NonfungiblePositionManager contract returns tickLower and tickUpper in the liquidity position data. In Uniswap V3, liquidity can be specified within a range, whereas the initial design of Uniswap had uniform distribution of liquidity. The specification of a liquidity range in subsequent versions is aimed at improving the utilization of liquidity capital.

> tickLower: The lower end of the tick range for the position
> tickUpper: The higher end of the tick range for the position

tickLower and tickUpper represent the upper and lower limits of the liquidity. Referring to the Uniswap documentation and its complex formulas, tickLower and tickUpper are essentially price boundaries recorded in exponential form. So, how can we calculate the price range for market-making from these "exponential boundaries"?

It's quite simple. Uniswap uses a base of ```1.0001```. Lower price: ```lowerPrice = 1.0001 ** tickLower```; Upper price: ```upperPrice = 1.0001 ** tickUpper```. The ```**``` operator represents exponentiation. For example, ```1.0001 ** 100``` calculates 1.0001 raised to the power of 100.

This calculated price range is denominated in token1. But what if we want to see the price range denominated in token0?

It can be calculated as follows:
Lower price: 1.0001 ** -tickUpper
Upper price: 1.0001 ** -tickLower
https://stocksharp.com/file/149684

Compare this to the NFT position we looked up on the chain:
https://stocksharp.com/file/149685
https://stocksharp.com/file/149686
https://stocksharp.com/file/149687

Parsing the Asset Value in the Current Liquidity Position

In addition to tickUpper and tickLower, the positions method of Uniswap's NonfungiblePositionManager contract returns another important data: liquidity.

By combining the liquidity, tickUpper, tickLower data from the position information with the current price data in the exchange pool, we can calculate the asset value in the current liquidity position.

You may wonder why we need to know the current price in the exchange pool to make the calculation.

This is because once you add liquidity, any price changes within the effective range of your liquidity position imply that your assets have been exchanged. If the current exchange price is not within the effective range of your liquidity provision, there won't be any changes. Therefore, there are three scenarios to consider when calculating:

- The tick of the current price is less than tickLower.
- The tick of the current price is greater than tickUpper.
- The tick of the current price is within the range of tickLower to tickUpper.

This corresponds to the following calculation and processing in the code:

```
if (currentTick <= posData.tickLower) {
amount0wei = Math.floor(posData.liquidity * ((sqrtRatioB - sqrtRatioA) / (sqrtRatioA * sqrtRatioB)))
} else if (currentTick > posData.tickUpper) {
amount1wei = Math.floor(posData.liquidity * (sqrtRatioB - sqrtRatioA))
} else if (currentTick >= posData.tickLower && currentTick < posData.tickUpper) {
amount0wei = Math.floor(posData.liquidity * ((sqrtRatioB - sqrtPrice) / (sqrtPrice * sqrtRatioB)))
amount1wei = Math.floor(posData.liquidity * (sqrtPrice - sqrtRatioA))
}
```

To perform the above calculations, we need to obtain the tick of the current price, which can be obtained directly from the pool contract. To get the address of the pool contract, we can use the getPool method of Uniswap's factory contract. By using the ```slot0``` method of the pool contract, we can retrieve the current price information, including the tick value we need.
https://stocksharp.com/file/149688

From: https://blog.mathquant.c...ations-guide-part-1.html

Thoughts on High-Frequency Trading Strategies (5)

2024-03-26T07:20:05Z

In the previous article, various methods for calculating mid-price were introduced, and a revised mid-price was proposed. In this article, we will delve deeper into this topic.

Data Required

We need order flow data and depth data for the top ten levels of the order book, collected from live trading with an update frequency of 100ms. For the sake of simplicity, we will not include real-time updates for the bid and ask prices. To reduce the data size, we have kept only 100,000 rows of depth data and separated the tick-by-tick market data into individual columns.

In [1]:
```
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import ast
%matplotlib inline
```

In [2]:
```
tick_size = 0.0001
```

In [3]:
```
trades = pd.read_csv('YGGUSDT_aggTrade.csv',names=['type','event_time', 'agg_trade_id','symbol', 'price', 'quantity', 'first_trade_id', 'last_trade_id',
'transact_time', 'is_buyer_maker'])
```

In [4]:
```
trades = trades.groupby(['transact_time','is_buyer_maker']).agg({
'transact_time':'last',
'agg_trade_id': 'last',
'price': 'first',
'quantity': 'sum',
'first_trade_id': 'first',
'last_trade_id': 'last',
'is_buyer_maker': 'last',
})
```

In [5]:
```
trades.index = pd.to_datetime(trades['transact_time'], unit='ms')
trades.index.rename('time', inplace=True)
trades['interval'] = trades['transact_time'] - trades['transact_time'].shift()
```

In [6]:
```
depths = pd.read_csv('YGGUSDT_depth.csv',names=['type','event_time', 'transact_time','symbol', 'u1', 'u2', 'u3', 'bids','asks'])
```

In [7]:
```
depths = depths.iloc[:100000]
```

In [8]:
```
depths['bids'] = depths['bids'].apply(ast.literal_eval).copy()
depths['asks'] = depths['asks'].apply(ast.literal_eval).copy()
```

In [9]:
```
def expand_bid(bid_data):
expanded = {}
for j, (price, quantity) in enumerate(bid_data):
expanded[f'bid_{j}_price'] = float(price)
expanded[f'bid_{j}_quantity'] = float(quantity)
return pd.Series(expanded)
def expand_ask(ask_data):
expanded = {}
for j, (price, quantity) in enumerate(ask_data):
expanded[f'ask_{j}_price'] = float(price)
expanded[f'ask_{j}_quantity'] = float(quantity)
return pd.Series(expanded)
# Apply to each line to get a new df
expanded_df_bid = depths['bids'].apply(expand_bid)
expanded_df_ask = depths['asks'].apply(expand_ask)
# Expansion on the original df
depths = pd.concat([depths, expanded_df_bid, expanded_df_ask], axis=1)
```

In [10]:
```
depths.index = pd.to_datetime(depths['transact_time'], unit='ms')
depths.index.rename('time', inplace=True);
```

In [11]:
```
trades = trades[trades['transact_time'] < depths['transact_time'].iloc[-1]]
```

Take a look at the distribution of the market in these 20 levels. It is in line with expectations, with more orders placed the further away from the market price. Additionally, buy orders and sell orders are roughly symmetrical.

In [14]:
```
bid_mean_list = []
ask_mean_list = []
for i in range(20):
bid_mean_list.append(round(depths[f'bid_{i}_quantity'].mean(),0))
ask_mean_list.append(round(depths[f'ask_{i}_quantity'].mean(),0))
plt.figure(figsize=(10, 5))
plt.plot(bid_mean_list);
plt.plot(ask_mean_list);
plt.grid(True)
```

Out[14]:

/upload/asset/28d4e2581a36fd970d055.png

Merge the depth data with the transaction data to facilitate the evaluation of prediction accuracy. Ensure that the transaction data is later than the depth data. Without considering latency, directly calculate the mean squared error between the predicted value and the actual transaction price. This is used to measure the accuracy of the prediction.

From the results, the error is highest for the average value of the bid and ask prices (mid_price). However, when changed to the weighted mid_price, the error immediately decreases significantly. Further improvement is observed by using the adjusted weighted mid_price. After receiving feedback on using I^3/2 only, it was checked and found that the results were better. Upon reflection, this is likely due to the different frequencies of events. When I is close to -1 and 1, it represents low probability events. In order to correct for these low probability events, the accuracy of predicting high-frequency events is compromised. Therefore, to prioritize high-frequency events, some adjustments were made (these parameters were purely trial-and-error and have limited practical significance in live trading).
https://stocksharp.com/file/149678

The results have improved slightly. As mentioned in the previous article, strategies should rely on more data for prediction. With the availability of more depth and order transaction data, the improvement gained from focusing on the order book is already weak.

In [15]:
```
df = pd.merge_asof(trades, depths, on='transact_time', direction='backward')
```

In [17]:
```
df['spread'] = round(df['ask_0_price'] - df['bid_0_price'],4)
df['mid_price'] = (df['bid_0_price']+ df['ask_0_price']) / 2
df['I'] = (df['bid_0_quantity'] - df['ask_0_quantity']) / (df['bid_0_quantity'] + df['ask_0_quantity'])
df['weight_mid_price'] = df['mid_price'] + df['spread']*df['I']/2
df['adjust_mid_price'] = df['mid_price'] + df['spread']*(df['I'])*(df['I']**8+1)/4
df['adjust_mid_price_2'] = df['mid_price'] + df['spread']*df['I']*(df['I']**2+1)/4
df['adjust_mid_price_3'] = df['mid_price'] + df['spread']*df['I']**3/2
df['adjust_mid_price_4'] = df['mid_price'] + df['spread']*(df['I']+0.3)*(df['I']**4+0.7)/3.8
```

In [18]:
```
print('Mean value Error in mid_price:', ((df['price']-df['mid_price'])**2).sum())
print('Error of pending order volume weighted mid_price:', ((df['price']-df['weight_mid_price'])**2).sum())
print('The error of the adjusted mid_price:', ((df['price']-df['adjust_mid_price'])**2).sum())
print('The error of the adjusted mid_price_2:', ((df['price']-df['adjust_mid_price_2'])**2).sum())
print('The error of the adjusted mid_price_3:', ((df['price']-df['adjust_mid_price_3'])**2).sum())
print('The error of the adjusted mid_price_4:', ((df['price']-df['adjust_mid_price_4'])**2).sum())
```

Out[18]:

Mean value Error in mid_price: 0.0048751924999999845
Error of pending order volume weighted mid_price: 0.0048373440193987035
The error of the adjusted mid_price: 0.004803654771638586
The error of the adjusted mid_price_2: 0.004808216498329721
The error of the adjusted mid_price_3: 0.004794984755260528
The error of the adjusted mid_price_4: 0.0047909595497071375

Consider the Second Level of Depth

We can follow the approach from the previous article to examine different ranges of a parameter and measure its contribution to the mid_price based on the changes in transaction price. Similar to the first level of depth, as I increases, the transaction price is more likely to increase, indicating a positive contribution from I.

Applying the same approach to the second level of depth, we find that although the effect is slightly smaller than the first level, it is still significant and should not be ignored. The third level of depth also shows a weak contribution, but with less monotonicity. Deeper depths have little reference value.

Based on the different contributions, we assign different weights to these three levels of imbalance parameters. By examining different calculation methods, we observe further reduction in prediction errors.

In [19]:
```
bins = np.linspace(-1, 1, 50)
df['change'] = (df['price'].pct_change().shift(-1))/tick_size
df['I_bins'] = pd.cut(df['I'], bins, labels=bins[1:])
df['I_2'] = (df['bid_1_quantity'] - df['ask_1_quantity']) / (df['bid_1_quantity'] + df['ask_1_quantity'])
df['I_2_bins'] = pd.cut(df['I_2'], bins, labels=bins[1:])
df['I_3'] = (df['bid_2_quantity'] - df['ask_2_quantity']) / (df['bid_2_quantity'] + df['ask_2_quantity'])
df['I_3_bins'] = pd.cut(df['I_3'], bins, labels=bins[1:])
df['I_4'] = (df['bid_3_quantity'] - df['ask_3_quantity']) / (df['bid_3_quantity'] + df['ask_3_quantity'])
df['I_4_bins'] = pd.cut(df['I_4'], bins, labels=bins[1:])
fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(8, 5))

axes[0][0].plot(df.groupby('I_bins')['change'].mean())
axes[0][0].set_title('I')
axes[0][0].grid(True)

axes[0][1].plot(df.groupby('I_2_bins')['change'].mean())
axes[0][1].set_title('I 2')
axes[0][1].grid(True)

axes[1][0].plot(df.groupby('I_3_bins')['change'].mean())
axes[1][0].set_title('I 3')
axes[1][0].grid(True)

axes[1][1].plot(df.groupby('I_4_bins')['change'].mean())
axes[1][1].set_title('I 4')
axes[1][1].grid(True)
plt.tight_layout();
```

Out[19]:
https://stocksharp.com/file/149683

In [20]:
```
df['adjust_mid_price_4'] = df['mid_price'] + df['spread']*(df['I']+0.3)*(df['I']**4+0.7)/3.8
df['adjust_mid_price_5'] = df['mid_price'] + df['spread']*(0.7*df['I']+0.3*df['I_2'])/2
df['adjust_mid_price_6'] = df['mid_price'] + df['spread']*(0.7*df['I']+0.3*df['I_2'])**3/2
df['adjust_mid_price_7'] = df['mid_price'] + df['spread']*(0.7*df['I']+0.3*df['I_2']+0.3)*((0.7*df['I']+0.3*df['I_2'])**4+0.7)/3.8
df['adjust_mid_price_8'] = df['mid_price'] + df['spread']*(0.7*df['I']+0.2*df['I_2']+0.1*df['I_3']+0.3)*((0.7*df['I']+0.3*df['I_2']+0.1*df['I_3'])**4+0.7)/3.8
```

In [21]:
```
print('The error of the adjusted mid_price_4:', ((df['price']-df['adjust_mid_price_4'])**2).sum())
print('The error of the adjusted mid_price_5:', ((df['price']-df['adjust_mid_price_5'])**2).sum())
print('The error of the adjusted mid_price_6:', ((df['price']-df['adjust_mid_price_6'])**2).sum())
print('The error of the adjusted mid_price_7:', ((df['price']-df['adjust_mid_price_7'])**2).sum())
print('The error of the adjusted mid_price_8:', ((df['price']-df['adjust_mid_price_8'])**2).sum())
```

Out[21]:

The error of the adjusted mid_price_4: 0.0047909595497071375
The error of the adjusted mid_price_5: 0.0047884350488318714
The error of the adjusted mid_price_6: 0.0047778319053133735
The error of the adjusted mid_price_7: 0.004773578540592192
The error of the adjusted mid_price_8: 0.004771415189297518

Considering the Transaction Data

Transaction data directly reflects the extent of long and short positions. After all, transactions involve real money, while placing orders has much lower costs and can even involve intentional deception. Therefore, when predicting the mid_price, strategies should focus on the transaction data.

In terms of form, we can define the imbalance of the average order arrival quantity as VI, with Vb and Vs representing the average quantity of buy and sell orders within a unit time interval, respectively.
https://stocksharp.com/file/149679

The results show that the arrival quantity in a short period of time has the most significant impact on price change prediction. When VI is between 0.1 and 0.9, it is negatively correlated with price, while outside this range, it is positively correlated with price. This suggests that when the market is not extreme and mainly oscillates, the price tends to revert to the mean. However, in extreme market conditions, such as when there are a large number of buy orders overwhelming sell orders, a trend emerges. Even without considering these low probability scenarios, assuming a negative linear relationship between the trend and VI significantly reduces the prediction error of the mid_price. The coefficient "a" represents the weight of this relationship in the equation.
https://stocksharp.com/file/149681

In [22]:
```
alpha=0.1
```

In [23]:
```
df['avg_buy_interval'] = None
df['avg_sell_interval'] = None
df.loc[df['is_buyer_maker'] == True, 'avg_buy_interval'] = df[df['is_buyer_maker'] == True]['transact_time'].diff().ewm(alpha=alpha).mean()
df.loc[df['is_buyer_maker'] == False, 'avg_sell_interval'] = df[df['is_buyer_maker'] == False]['transact_time'].diff().ewm(alpha=alpha).mean()
```

In [24]:
```
df['avg_buy_quantity'] = None
df['avg_sell_quantity'] = None
df.loc[df['is_buyer_maker'] == True, 'avg_buy_quantity'] = df[df['is_buyer_maker'] == True]['quantity'].ewm(alpha=alpha).mean()
df.loc[df['is_buyer_maker'] == False, 'avg_sell_quantity'] = df[df['is_buyer_maker'] == False]['quantity'].ewm(alpha=alpha).mean()
```

In [25]:
```
df['avg_buy_quantity'] = df['avg_buy_quantity'].fillna(method='ffill')
df['avg_sell_quantity'] = df['avg_sell_quantity'].fillna(method='ffill')
df['avg_buy_interval'] = df['avg_buy_interval'].fillna(method='ffill')
df['avg_sell_interval'] = df['avg_sell_interval'].fillna(method='ffill')

df['avg_buy_rate'] = 1000 / df['avg_buy_interval']
df['avg_sell_rate'] =1000 / df['avg_sell_interval']

df['avg_buy_volume'] = df['avg_buy_rate']*df['avg_buy_quantity']
df['avg_sell_volume'] = df['avg_sell_rate']*df['avg_sell_quantity']
```

In [26]:
```
df['I'] = (df['bid_0_quantity']- df['ask_0_quantity']) / (df['bid_0_quantity'] + df['ask_0_quantity'])
df['OI'] = (df['avg_buy_rate']-df['avg_sell_rate']) / (df['avg_buy_rate'] + df['avg_sell_rate'])
df['QI'] = (df['avg_buy_quantity']-df['avg_sell_quantity']) / (df['avg_buy_quantity'] + df['avg_sell_quantity'])
df['VI'] = (df['avg_buy_volume']-df['avg_sell_volume']) / (df['avg_buy_volume'] + df['avg_sell_volume'])
```

In [27]:
```
bins = np.linspace(-1, 1, 50)
df['VI_bins'] = pd.cut(df['VI'], bins, labels=bins[1:])
plt.plot(df.groupby('VI_bins')['change'].mean());
plt.grid(True)
```

Out[27]:
https://stocksharp.com/file/149680

In [28]:
```
df['adjust_mid_price'] = df['mid_price'] + df['spread']*df['I']/2
df['adjust_mid_price_9'] = df['mid_price'] + df['spread']*(-df['OI'])*2
df['adjust_mid_price_10'] = df['mid_price'] + df['spread']*(-df['VI'])*1.4
```

In [29]:
```
print('The error of the adjusted mid_price:', ((df['price']-df['adjust_mid_price'])**2).sum())
print('The error of the adjusted mid_price_9:', ((df['price']-df['adjust_mid_price_9'])**2).sum())
print('The error of the adjusted mid_price_10:', ((df['price']-df['adjust_mid_price_10'])**2).sum())
```

Out[29]:

The error of the adjusted mid_price: 0.0048373440193987035
The error of the adjusted mid_price_9: 0.004629586542840461
The error of the adjusted mid_price_10: 0.004401790287167206

The Comprehensive Mid-price

Considering that both order book imbalance and transaction data are helpful for predicting the mid_price, we can combine these two parameters together. The assignment of weights in this case is arbitrary and does not take into account boundary conditions. In extreme cases, the predicted mid_price may not fall between the bid and ask prices. However, as long as the prediction error can be reduced, these details are not of great concern.

In the end, the prediction error is reduced from 0.00487 to 0.0043. At this point, we will not delve further into the topic. There are still many aspects to explore when it comes to predicting the mid_price, as it is essentially predicting the price itself. Everyone is encouraged to try their own approaches and techniques.

In [30]:
```
#Note that the VI needs to be delayed by one to use
df['CI'] = -1.5*df['VI'].shift()+0.7*(0.7*df['I']+0.2*df['I_2']+0.1*df['I_3'])**3
```

In [31]:
```
df['adjust_mid_price_11'] = df['mid_price'] + df['spread']*(df['CI'])
print('The error of the adjusted mid_price_11:', ((df['price']-df['adjust_mid_price_11'])**2).sum())
```

Out[31]:

The error of the adjusted mid_price_11: 0.0043001941412563575

Summary

The article combines depth data and transaction data to further improve the calculation method of the mid-price. It provides a method to measure accuracy and improves the accuracy of price change prediction. Overall, the parameters are not rigorous and are for reference only. With a more accurate mid-price, the next step is to conduct backtesting using the mid-price in practical applications. This part of the content is extensive, so updates will be paused for a period of time.

From: https://blog.mathquant.c...rading-strategies-5.html

Thoughts on High-Frequency Trading Strategies (4)

2024-03-26T05:11:42Z

The previous article demonstrated the need for dynamically adjusting parameters and how to evaluate the quality of estimates by studying the order arrival intervals. This article will focus on depth data and study the mid-price (also known as fair-price or micro-price).

Depth Data

Binance provides historical data downloads for best_bid_price (the highest buying price), best_bid_quantity (the quantity at the best bid price), best_ask_price (the lowest selling price), best_ask_quantity (the quantity at the best ask price), and transaction_time. This data does not include the second or deeper order book levels. The analysis in this article is based on the YGG market on August 7th, which experienced significant volatility with over 9 million data points.

First, let's take a look at the market conditions on that day. There were large fluctuations, and the order book volume changed significantly along with the market volatility. The spread, particularly, indicated the extent of market fluctuations, which is the difference between the best ask and bid prices. In the statistics of the YGG market on that day, the spread was larger than one tick for 20% of the time. In this era of various trading bots competing in the order book, such situations are becoming increasingly rare.

In [1]:
```
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
```

In [2]:
```
books = pd.read_csv('YGGUSDT-bookTicker-2023-08-07.csv')
```

In [3]:
```
tick_size = 0.0001
```

In [4]:
```
books['date'] = pd.to_datetime(books['transaction_time'], unit='ms')
books.index = books['date']
```

In [5]:
```
books['spread'] = round(books['best_ask_price'] - books['best_bid_price'],4)
```

In [6]:
```
books['best_bid_price'][::10].plot(figsize=(10,5),grid=True);
```

Out[6]:
https://stocksharp.com/file/149672

In [7]:
```
books['best_bid_qty'][::10].rolling(10000).mean().plot(figsize=(10,5),grid=True);
books['best_ask_qty'][::10].rolling(10000).mean().plot(figsize=(10,5),grid=True);
```

Out[7]:
https://stocksharp.com/file/149677

In [8]:
```
(books['spread'][::10]/tick_size).rolling(10000).mean().plot(figsize=(10,5),grid=True);
```

Out[8]:
https://stocksharp.com/file/149675

In [9]:
```
books['spread'].value_counts()[books['spread'].value_counts()>500]/books['spread'].value_counts().sum()
```

Out[9]:
https://stocksharp.com/file/149667

Imbalanced Quotes

Imbalanced quotes are observed from the significant difference in the order book volumes between the buy and sell orders most of the time. This difference has a strong predictive effect on short-term market trends, similar to the reason mentioned earlier that a decrease in buy order volume often leads to a decline. If one side of the order book is significantly smaller than the other, assuming the active buying and selling orders are similar in volume, there is a greater likelihood of the smaller side being consumed, thereby driving price changes. Imbalanced quotes are represented by the letter "I".
https://stocksharp.com/file/149671

Where Q_b represents the amount of pending buy orders (best_bid_qty) and Q_a represents the amount of pending sell orders (best_ask_qty).

Define mid-price:
https://stocksharp.com/file/149674

The graph below shows the relationship between the rate of change of mid-price over the next 1 interval and the imbalance I. As expected, the more likely the price is to increase as I increases and the closer it gets to 1, the more the price change accelerates. In high-frequency trading, the introduction of the intermediate price is to better predict future price changes, that is, and the future price difference is smaller, the better the intermediate price is defined. Obviously the imbalance of pending orders provides additional information for the prediction of the strategy, with this in mind, defining the weighted mid-price:
https://stocksharp.com/file/149668

In [10]:
```
books['I'] = books['best_bid_qty'] / (books['best_bid_qty'] + books['best_ask_qty'])
```

In [11]:
```
books['mid_price'] = (books['best_ask_price'] + books['best_bid_price'])/2
```

In [12]:
```
bins = np.linspace(0, 1, 51)
books['I_bins'] = pd.cut(books['I'], bins, labels=bins[1:])
books['price_change'] = (books['mid_price'].pct_change()/tick_size).shift(-1)
avg_change = books.groupby('I_bins')['price_change'].mean()
plt.figure(figsize=(8,5))
plt.plot(avg_change)
plt.xlabel('I Value Range')
plt.ylabel('Average Mid Price Change Rate');
plt.grid(True)
```

Out[12]:
https://stocksharp.com/file/149663

In [13]:
```
books['weighted_mid_price'] = books['mid_price'] + books['spread']*books['I']/2
bins = np.linspace(-1, 1, 51)
books['I_bins'] = pd.cut(books['I'], bins, labels=bins[1:])
books['weighted_price_change'] = (books['weighted_mid_price'].pct_change()/tick_size).shift(-1)
avg_change = books.groupby('I_bins')['weighted_price_change'].mean()
plt.figure(figsize=(8,5))
plt.plot(avg_change)
plt.xlabel('I Value Range')
plt.ylabel('Weighted Average Mid Price Change Rate');
plt.grid(True)
```

Out[13]:
https://stocksharp.com/file/149670

Adjust Weighted Mid-Price:

From the graph, it can be observed that the weighted mid-price shows smaller variations compared to different values of I, indicating that it is a better fit. However, there are still some deviations, particularly around 0.2 and 0.8. This suggests that I still provides additional information. The assumption of a completely linear relationship between the price correction term and I, as implied by the weighted mid-price, does not align with reality. It can be seen from the graph that the deviation speed increases when I approaches 0 and 1, indicating a non-linear relationship.

To provide a more intuitive representation, here is a redefinition of I:

Revised definition of I:
https://stocksharp.com/file/149666

At this point:
https://stocksharp.com/file/149673

Upon observation, it can be noticed that the weighted mid-price is a correction to the average mid-price, where the correction term is multiplied by the spread. The correction term is a function of I, and the weighted mid-price assumes a simple relationship of I/2. In this case, the advantage of the adjusted I distribution (-1, 1) becomes apparent, as I is symmetric around the origin, making it convenient to find a fitting relationship for the function. By examining the graph, it appears that this function should satisfy odd powers of I, as it aligns with the rapid growth on both sides and symmetry around the origin. Additionally, it can be observed that values near the origin are close to linear. Furthermore, when I is 0, the function result is 0, and when I is 1, the function result is 0.5. Therefore, it is speculated that the function is of the form:
https://stocksharp.com/file/149665

Here N is a positive even number, after actual testing, it is better when N is 8. So far this paper presents the modified weighted mid-price:
https://stocksharp.com/file/149664

At this point, the prediction of mid-price changes is no longer significantly related to I. Although this result is slightly better than the simple weighted mid-price, it is still not applicable in real trading scenarios. This is just a proposed approach. In a 2017 article by S Stoikov, the concept of [Micro-Price](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2970694) is introduced using a Markov chain approach, and related code is provided. Researchers can explore this approach further.

In [14]:
```
books['I'] = (books['best_bid_qty'] - books['best_ask_qty']) / (books['best_bid_qty'] + books['best_ask_qty'])
```

In [15]:
```
books['weighted_mid_price'] = books['mid_price'] + books['spread']*books['I']/2
bins = np.linspace(-1, 1, 51)
books['I_bins'] = pd.cut(books['I'], bins, labels=bins[1:])
books['weighted_price_change'] = (books['weighted_mid_price'].pct_change()/tick_size).shift(-1)
avg_change = books.groupby('I_bins')['weighted_price_change'].mean()
plt.figure(figsize=(8,5))
plt.plot(avg_change)
plt.xlabel('I Value Range')
plt.ylabel('Weighted Average Mid Price Change Rate');
plt.grid(True)
```

Out[15]:
https://stocksharp.com/file/149669

In [16]:
```
books['adjust_mid_price'] = books['mid_price'] + books['spread']*books['I']*(books['I']**8+1)/4
bins = np.linspace(-1, 1, 51)
books['I_bins'] = pd.cut(books['I'], bins, labels=bins[1:])
books['adjust_mid_price'] = (books['adjust_mid_price'].pct_change()/tick_size).shift(-1)
avg_change = books.groupby('I_bins')['adjust_mid_price'].mean()
plt.figure(figsize=(8,5))
plt.plot(avg_change)
plt.xlabel('I Value Range')
plt.ylabel('Weighted Average Mid Price Change Rate');
plt.grid(True)
```

Out[16]:
https://stocksharp.com/file/149676

Summary

The mid-price is crucial for high-frequency strategies as it serves as a prediction of short-term future prices. Therefore, it is important for the mid-price to be as accurate as possible. The mid-price approaches discussed earlier are based on order book data, as only the top level of the order book is utilized in the analysis. In live trading, strategies should aim to utilize all available data, including trade data, to validate mid-price predictions against actual transaction prices. I recall Stoikov mentioning in a Twitter that the real mid-price should be a weighted average of the probabilities of the bid and ask prices being executed. This issue has been explored in the previous articles. Due to length constraints, further details on these topics will be discussed in the next article.

From: https://blog.mathquant.c...rading-strategies-4.html

Thoughts on High-Frequency Trading Strategies (3)

2024-03-26T03:09:54Z

In the previous article, I introduced how to model cumulative trading volume and analyzed the phenomenon of price impact. In this article, I will continue to analyze the trades order data. YGG recently launched Binance U-based contracts, and the price fluctuations have been significant, with trading volume even surpassing BTC at one point. Today, I will analyze it.

Order Time Intervals

In general, it is assumed that the arrival time of orders follows a Poisson process. There is an article that introduces the [Poisson process](https://www.ruanyifeng.com/blog/2015/06/poisson-distribution.html) . Here, I will provide empirical evidence.

I downloaded the aggTrades data for August 5th, which consists of 1,931,193 trades, which is quite significant. First, let's take a look at the distribution of buy orders. We can see a non-smooth local peak around 100ms and 500ms, which is likely caused by iceberg orders placed by trading bots at regular intervals. This may also be one of the reasons for the unusual market conditions that day.

The probability mass function (PMF) of the Poisson distribution is given by the following formula:
https://stocksharp.com/file/149661

Where:

- κ is the number of events we are interested in.
- λ is the average rate of events occurring per unit time (or unit space).
- https://stocksharp.com/file/149657 represents the probability of exactly κ events occurring, given the average rate λ.

In a Poisson process, the time intervals between events follow an exponential distribution. The probability density function (PDF) of the exponential distribution is given by the following formula:
https://stocksharp.com/file/149655

The fitting results show that there is a significant difference between the observed data and the expected Poisson distribution. The Poisson process underestimates the frequency of long time intervals and overestimates the frequency of short time intervals. (The actual distribution of intervals is closer to a modified Pareto distribution)

In [1]:
```
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
```

In [2]:
```
trades = pd.read_csv('YGGUSDT-aggTrades-2023-08-05.csv')
trades['date'] = pd.to_datetime(trades['transact_time'], unit='ms')
trades.index = trades['date']
buy_trades = trades[trades['is_buyer_maker']==False].copy()
buy_trades = buy_trades.groupby('transact_time').agg({
'agg_trade_id': 'last',
'price': 'last',
'quantity': 'sum',
'first_trade_id': 'first',
'last_trade_id': 'last',
'is_buyer_maker': 'last',
'date': 'last',
'transact_time':'last'
})
buy_trades['interval']=buy_trades['transact_time'] - buy_trades['transact_time'].shift()
buy_trades.index = buy_trades['date']
```

In [10]:
```
buy_trades['interval'][buy_trades['interval']<1000].plot.hist(bins=200,figsize=(10, 5));
```

Out[10]:
https://stocksharp.com/file/149656

In [20]:
```
Intervals = np.array(range(0, 1000, 5))
mean_intervals = buy_trades['interval'].mean()
buy_rates = 1000/mean_intervals
probabilities = np.array([np.mean(buy_trades['interval'] > interval) for interval in Intervals])
probabilities_s = np.array([np.e**(-buy_rates*interval/1000) for interval in Intervals])

plt.figure(figsize=(10, 5))
plt.plot(Intervals, probabilities)
plt.plot(Intervals, probabilities_s)
plt.xlabel('Intervals')
plt.ylabel('Probability')
plt.grid(True)
```

Out[20]:
https://stocksharp.com/file/149659

When comparing the distribution of the number of order occurrences within 1 second with the Poisson distribution, the difference is also significant. The Poisson distribution significantly underestimates the frequency of rare events. Possible reasons for this are:

- Non-constant rate of occurrence: The Poisson process assumes that the average rate of events occurring within any given time interval is constant. If this assumption does not hold, then the distribution of the data will deviate from the Poisson distribution.
- Interactions between processes: Another fundamental assumption of the Poisson process is that events are independent of each other. If events in the real world interact with each other, their distribution may deviate from the Poisson distribution.

In other words, in a real-world environment, the frequency of order occurrences is non-constant, and it needs to be updated in real-time. There may also be an incentive effect, where more orders within a fixed time period stimulate more orders. This makes strategies unable to rely on a single fixed parameter.

In [190]:
```
result_df = buy_trades.resample('1S').agg({
'price': 'count',
'quantity': 'sum'
}).rename(columns={'price': 'order_count', 'quantity': 'quantity_sum'})
```

In [219]:
```
count_df = result_df['order_count'].value_counts().sort_index()[result_df['order_count'].value_counts()>20]
(count_df/count_df.sum()).plot(figsize=(10,5),grid=True,label='sample pmf');

from scipy.stats import poisson
prob_values = poisson.pmf(count_df.index, 1000/mean_intervals)

plt.plot(count_df.index, prob_values,label='poisson pmf');
plt.legend() ;
```

Out[219]:
https://stocksharp.com/file/149662

Real-time Parameter Updating

From the analysis of order intervals earlier, it can be concluded that fixed parameters are not suitable for the real market conditions, and the key parameters describing the market in the strategy need to be updated in real-time. The most straightforward solution is to use a sliding window moving average. The two graphs below show the frequency of buy orders within 1 second and the mean of trading volume with a window size of 1000. It can be observed that there is a clustering phenomenon in trading, where the frequency of orders is significantly higher than usual for a period of time, and the volume also increases synchronously. Here, the mean of the previous values is used to predict the latest value, and the mean absolute error of the residuals is used to measure the quality of the prediction.

From the graphs, we can also understand why the order frequency deviates so much from the Poisson distribution. Although the mean number of orders per second is only 8.5, extreme cases deviate significantly from this value.

It is found that using the mean of the previous two seconds to predict yields the smallest residual error, and it is much better than simply using the mean for prediction results.

In [221]:
```
result_df['order_count'].rolling(1000).mean().plot(figsize=(10,5),grid=True);
```

Out[221]:
https://stocksharp.com/file/149660

In [193]:
```
result_df['quantity_sum'].rolling(1000).mean().plot(figsize=(10,5),grid=True);
```

Out[193]:
https://stocksharp.com/file/149658

In [195]:
```
(result_df['order_count'] - result_df['mean_count'].mean()).abs().mean()
```

Out[195]:

6.985628185332997

In [205]:
```
result_df['mean_count'] = result_df['order_count'].rolling(2).mean()
(result_df['order_count'] - result_df['mean_count'].shift()).abs().mean()
```

Out[205]:

3.091737586730269

Summary

This article briefly explains the reasons for the deviation of order time intervals from the Poisson process, mainly due to the variation of parameters over time. In order to accurately predict the market, strategies need to make real-time forecasts of the fundamental parameters of the market. Residuals can be used to measure the quality of the predictions. The example provided above is a simple demonstration, and there is extensive research on specific time series analysis, volatility clustering, and other related topics, the above demonstration can be further improved.

From: https://blog.mathquant.c...rading-strategies-3.html

Thoughts on High-Frequency Trading Strategies (2)

2024-03-26T01:19:48Z

Accumulated Trading Amount Modeling

In the previous article, we derived an expression for the probability of a single trade amount being greater than a certain value.
https://stocksharp.com/file/149650

We are also interested in the distribution of trading amount over a period of time, which intuitively should be related to the individual trade amount and order frequency. Below, we process the data in fixed intervals and plot its distribution, similar to what was done in the previous section.

In [1]:
```
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
```

In [2]:
```
trades = pd.read_csv('HOOKUSDT-aggTrades-2023-01-27.csv')
trades['date'] = pd.to_datetime(trades['transact_time'], unit='ms')
trades.index = trades['date']
buy_trades = trades[trades['is_buyer_maker']==False].copy()
buy_trades = buy_trades.groupby('transact_time').agg({
'agg_trade_id': 'last',
'price': 'last',
'quantity': 'sum',
'first_trade_id': 'first',
'last_trade_id': 'last',
'is_buyer_maker': 'last',
'date': 'last',
'transact_time':'last'
})
buy_trades['interval']=buy_trades['transact_time'] - buy_trades['transact_time'].shift()
buy_trades.index = buy_trades['date']
```

We combine the individual trade amounts at intervals of 1 second to obtain the aggregated trading amount, excluding periods with no trading activity. We then fit this aggregated amount using the distribution derived from the single trade amount analysis mentioned earlier. The results show a good fit when considering each trade within the 1-second interval as a single trade, effectively solving the problem. However, when the time interval is extended relative to the trading frequency, we observe an increase in errors. Further research reveals that this error is caused by the correction term introduced by the Pareto distribution. This suggests that as the time interval lengthens and includes more individual trades, the aggregation of multiple trades approaches the Pareto distribution more closely, necessitating the removal of the correction term.

In [3]:
```
df_resampled = buy_trades['quantity'].resample('1S').sum()
df_resampled = df_resampled.to_frame(name='quantity')
df_resampled = df_resampled[df_resampled['quantity']>0]
```

In [4]:
```
# Cumulative distribution in 1s
depths = np.array(range(0, 3000, 5))
probabilities = np.array([np.mean(df_resampled['quantity'] > depth) for depth in depths])
mean = df_resampled['quantity'].mean()
alpha = np.log(np.mean(df_resampled['quantity'] > mean))/np.log(2.05)
probabilities_s = np.array([((1+20**(-depth/mean))*depth/mean+1)**(alpha) for depth in depths])

plt.figure(figsize=(10, 5))
plt.plot(depths, probabilities)
plt.plot(depths, probabilities_s)
plt.xlabel('Depth')
plt.ylabel('Probability of execution')
plt.title('Execution probability at different depths')
plt.grid(True)
```

Out[4]:
https://stocksharp.com/file/149653

In [5]:
```
df_resampled = buy_trades['quantity'].resample('30S').sum()
df_resampled = df_resampled.to_frame(name='quantity')
df_resampled = df_resampled[df_resampled['quantity']>0]
depths = np.array(range(0, 12000, 20))
probabilities = np.array([np.mean(df_resampled['quantity'] > depth) for depth in depths])
mean = df_resampled['quantity'].mean()
alpha = np.log(np.mean(df_resampled['quantity'] > mean))/np.log(2.05)
probabilities_s = np.array([((1+20**(-depth/mean))*depth/mean+1)**(alpha) for depth in depths])
alpha = np.log(np.mean(df_resampled['quantity'] > mean))/np.log(2)
probabilities_s_2 = np.array([(depth/mean+1)**alpha for depth in depths]) # No amendment

plt.figure(figsize=(10, 5))
plt.plot(depths, probabilities,label='Probabilities (True)')
plt.plot(depths, probabilities_s, label='Probabilities (Simulation 1)')
plt.plot(depths, probabilities_s_2, label='Probabilities (Simulation 2)')
plt.xlabel('Depth')
plt.ylabel('Probability of execution')
plt.title('Execution probability at different depths')
plt.legend()
plt.grid(True)
```

Out[5]:
https://stocksharp.com/file/149654

Now summarize a general formula for the distribution of accumulated trading amount for different time periods, using the distribution of single transaction amount to fit, instead of separately calculating each time. Here is the formula:
https://stocksharp.com/file/149652
Here, avg_interval represents the average interval of single transactions, and avg_interval_T represents the average interval of the interval that needs to be estimated. It may sound a bit confusing. If we want to estimate the trading amount for 1 second, we need to calculate the average interval between events containing transactions within 1 second. If the arrival probability of orders follows a Poisson distribution, it should be directly estimable. However, in reality, there is a significant deviation, but I won't elaborate on it here.

Note that the probability of trading amount exceeding a specific value within a certain interval of time and the actual probability of trading at that position in the depth should be quite different. As the waiting time increases, the possibility of changes in the order book increases, and trading also leads to changes in the depth. Therefore, the probability of trading at the same depth position changes in real-time as the data updates.

In [6]:
```
df_resampled = buy_trades['quantity'].resample('2S').sum()
df_resampled = df_resampled.to_frame(name='quantity')
df_resampled = df_resampled[df_resampled['quantity']>0]
depths = np.array(range(0, 6500, 10))
probabilities = np.array([np.mean(df_resampled['quantity'] > depth) for depth in depths])
mean = buy_trades['quantity'].mean()
adjust = buy_trades['interval'].mean() / 2620
alpha = np.log(np.mean(buy_trades['quantity'] > mean))/0.7178397931503168
probabilities_s = np.array([((1+20**(-depth*adjust/mean))*depth*adjust/mean+1)**(alpha) for depth in depths])

plt.figure(figsize=(10, 5))
plt.plot(depths, probabilities)
plt.plot(depths, probabilities_s)
plt.xlabel('Depth')
plt.ylabel('Probability of execution')
plt.title('Execution probability at different depths')
plt.grid(True)
```

Out[6]:
https://stocksharp.com/file/149651

Single Trade Price Impact

Trade data is valuable, and there is still a lot of data that can be mined. We should pay close attention to the impact of orders on prices, as this affects the positioning of strategies. Similarly, aggregating data based on transact_time, we calculate the difference between the last price and the first price. If there is only one order, the price difference is 0. Interestingly, there are a few data results that are negative, which may be due to the ordering of the data, but we won't delve into it here.

The results show that the proportion of trades that did not cause any impact is as high as 77%, while the proportion of trades causing a price movement of 1 tick is 16.5%, 2 ticks is 3.7%, 3 ticks is 1.2%, and more than 4 ticks is less than 1%. This basically follows the characteristics of an exponential function, but the fitting is not precise.

The trade amount causing the corresponding price difference was also analyzed, excluding distortions caused by excessive impact. It shows a linear relationship, with approximately 1 tick of price fluctuation caused by every 1000 units of amount. This can also be understood as an average of around 1000 units of orders placed near each price level in the order book.

In [7]:
```
diff_df = trades[trades['is_buyer_maker']==False].groupby('transact_time')['price'].agg(lambda x: abs(round(x.iloc[-1] - x.iloc[0],3)) if len(x) > 1 else 0)
buy_trades['diff'] = buy_trades['transact_time'].map(diff_df)
```

In [8]:
```
diff_counts = buy_trades['diff'].value_counts()
diff_counts[diff_counts>10]/diff_counts.sum()
```

Out[8]:
https://stocksharp.com/file/149649

In [9]:
```
diff_group = buy_trades.groupby('diff').agg({
'quantity': 'mean',
'diff': 'last',
})
```

In [10]:
```
diff_group['quantity'][diff_group['diff']>0][diff_group['diff']<0.01].plot(figsize=(10,5),grid=True);
```

Out[10]:
https://stocksharp.com/file/149648

Fixed Interval Price Impact

Let's analyze the price impact within a 2-second interval. The difference here is that there may be negative values. However, since we are only considering buy orders, the impact on the symmetrical position would be one tick higher. Continuing to observe the relationship between trade amount and impact, we only consider results greater than 0. The conclusion is similar to that of a single order, showing an approximate linear relationship, with approximately 2000 units of amount needed for each tick.

In [11]:
```
df_resampled = buy_trades.resample('2S').agg({
'price': ['first', 'last', 'count'],
'quantity': 'sum'
})
df_resampled['price_diff'] = round(df_resampled[('price', 'last')] - df_resampled[('price', 'first')],3)
df_resampled['price_diff'] = df_resampled['price_diff'].fillna(0)
result_df_raw = pd.DataFrame({
'price_diff': df_resampled['price_diff'],
'quantity_sum': df_resampled[('quantity', 'sum')],
'data_count': df_resampled[('price', 'count')]
})
result_df = result_df_raw[result_df_raw['price_diff'] != 0]
```

In [12]:
```
result_df['price_diff'][abs(result_df['price_diff'])<0.016].value_counts().sort_index().plot.bar(figsize=(10,5));
```

Out[12]:
https://stocksharp.com/file/149646

In [23]:
```
result_df['price_diff'].value_counts()[result_df['price_diff'].value_counts()>30]
```

Out[23]:
https://stocksharp.com/file/149645

In [14]:
```
diff_group = result_df.groupby('price_diff').agg({ 'quantity_sum': 'mean'})
```

In [15]:
```
diff_group[(diff_group.index>0) & (diff_group.index<0.015)].plot(figsize=(10,5),grid=True);
```

Out[15]:
https://stocksharp.com/file/149647

Trade Amount's Price Impact

Previously, we determined the trade amount required for a tick change, but it was not precise as it was based on the assumption that the impact had already occurred. Now, let's reverse the perspective and examine the price impact caused by trade amount.

In this analysis, the data is sampled every 1 second, with each step representing 100 units of amount. We then calculated the price changes within this amount range. Here are some valuable conclusions:

1. When the buy order amount is below 500, the expected price change is a decrease, which is as expected since there are also sell orders impacting the price.
2. At lower trade amounts, there is a linear relationship, meaning that the larger the trade amount, the greater the price increase.
3. As the buy order amount increases, the price change becomes more significant. This often indicates a price breakthrough, which may later regress. Additionally, the fixed interval sampling adds to the data instability.
4. It is important to pay attention to the upper part of the scatter plot, which corresponds to the increase in price with trade amount.
5. For this specific trading pair, we provide a rough version of the relationship between trade amount and price change.
https://stocksharp.com/file/149642

Where "C" represents the change in price and "Q" represents the amount of buy orders.

In [16]:
```
df_resampled = buy_trades.resample('1S').agg({
'price': ['first', 'last', 'count'],
'quantity': 'sum'
})
df_resampled['price_diff'] = round(df_resampled[('price', 'last')] - df_resampled[('price', 'first')],3)
df_resampled['price_diff'] = df_resampled['price_diff'].fillna(0)
result_df_raw = pd.DataFrame({
'price_diff': df_resampled['price_diff'],
'quantity_sum': df_resampled[('quantity', 'sum')],
'data_count': df_resampled[('price', 'count')]
})
result_df = result_df_raw[result_df_raw['price_diff'] != 0]
```

In [24]:
```
df = result_df.copy()
bins = np.arange(0, 30000, 100) #
labels = [f'{i}-{i+100-1}' for i in bins[:-1]]
df.loc[:, 'quantity_group'] = pd.cut(df['quantity_sum'], bins=bins, labels=labels)
grouped = df.groupby('quantity_group')['price_diff'].mean()
```

In [25]:
```
grouped_df = pd.DataFrame(grouped).reset_index()
grouped_df['quantity_group_center'] = grouped_df['quantity_group'].apply(lambda x: (float(x.split('-')[0]) + float(x.split('-')[1])) / 2)

plt.figure(figsize=(10,5))
plt.scatter(grouped_df['quantity_group_center'], grouped_df['price_diff'],s=10)
plt.plot(grouped_df['quantity_group_center'], np.array(grouped_df['quantity_group_center'].values)/2e6-0.000352,color='red')
plt.xlabel('quantity_group_center')
plt.ylabel('average price_diff')
plt.title('Scatter plot of average price_diff by quantity_group')
plt.grid(True)
```

Out[25]:
https://stocksharp.com/file/149644

In [19]:
```
grouped_df.head(10)
```

Out[19]:
, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
https://stocksharp.com/file/149643

Preliminary Optimal Order Placement

With the modeling of trade amount and the rough model of price impact corresponding to trade amount, it seems possible to calculate the optimal order placement. Let's make some assumptions and provide an irresponsible optimal price position.

1. Assume that the price regresses to its original value after the impact (which is highly unlikely and would require further analysis of the price change after the impact).
2. Assume that the distribution of trade amount and order frequency during this period follows a preset pattern (which is also inaccurate, as we are estimating based on one day's data and trading exhibits clear clustering phenomena).
3. Assume that only one sell order occurs during the simulated time and then is closed.
4. Assume that after the order is executed, there are other buy orders that continue to push up the price, especially when the amount is very low. This effect is ignored here, and it is simply assumed that the price will regress.

Let's start by writing a simple expected return, which is the probability of cumulative buy orders exceeding Q within 1 second, multiplied by the expected return rate (i.e., the price impact).
https://stocksharp.com/file/149640

Based on the graph, the maximum expected return is approximately 2500, which is about 2.5 times the average trade amount. This suggests that the sell order should be placed at a price position of 2500. It is important to emphasize that the horizontal axis represents trade amount within 1 second and should not be equated with depth position. Additionally, this analysis is based on trades data and lacks important depth data.

Summary

We have discovered that trade amount distribution at different time intervals is a simple scaling of the distribution of individual trade amounts. We have also developed a simple expected return model based on price impact and trade probability. The results of this model align with our expectations, showing that if the sell order amount is low, it indicates a price decrease, and a certain amount is needed for profit potential. The probability decreases as the trade amount increases, with an optimal size in between, which represents the optimal order placement strategy. However, this model is still too simplistic. In the next article, I will delve deeper into this topic.

In [20]:
```
# Cumulative distribution in 1s
df_resampled = buy_trades['quantity'].resample('1S').sum()
df_resampled = df_resampled.to_frame(name='quantity')
df_resampled = df_resampled[df_resampled['quantity']>0]

depths = np.array(range(0, 15000, 10))
mean = df_resampled['quantity'].mean()
alpha = np.log(np.mean(df_resampled['quantity'] > mean))/np.log(2.05)
probabilities_s = np.array([((1+20**(-depth/mean))*depth/mean+1)**(alpha) for depth in depths])
profit_s = np.array([depth/2e6-0.000352 for depth in depths])
plt.figure(figsize=(10, 5))
plt.plot(depths, probabilities_s*profit_s)
plt.xlabel('Q')
plt.ylabel('Excpet profit')
plt.grid(True)
```

Out[20]:
https://stocksharp.com/file/149641

From: https://blog.mathquant.c...rading-strategies-2.html

Thoughts on High-Frequency Trading Strategies (1)

2024-03-25T09:08:04Z

I have written two articles on high-frequency trading of digital currencies, namely "[Digital Currency High-Frequency Strategy Detailed Introduction](https://www.fmz.com/bbs-topic/10009)" and "[Earn 80 Times in 5 Days, the Power of High-frequency Strategy](https://www.fmz.com/bbs-topic/9750)". However, these articles can only be considered as sharing experiences and provide a general overview. This time, I plan to write a series of articles to introduce the thought process behind high-frequency trading from scratch. I hope to keep it concise and clear, but due to my limited expertise, my understanding of high-frequency trading may not be very in-depth. This article should be seen as a starting point for discussion, and I welcome corrections and guidance from experts.

Source of High-Frequency Profits

In my previous articles, I mentioned that high-frequency strategies are particularly suitable for markets with extremely volatile fluctuations. The price changes of a trading instrument within a short period of time consist of overall trends and oscillations. While it is indeed profitable if we can accurately predict trend changes, this is also the most challenging aspect. In this article, I will primarily focus on high-frequency maker strategies and will not delve into trend prediction. In oscillating markets, by placing bid and ask orders strategically, if the frequency of executions is high enough and the profit margin is significant, it can cover potential losses caused by trends. In this way, profitability can be achieved without predicting market movements. Currently, exchanges provide rebates for maker trades, which are also a component of profits. The more competitive the market, the higher the proportion of rebates should be.

Problems to be Addressed

1. The first problem in implementing a strategy that places both buy and sell orders is determining where to place these orders. The closer the orders are placed to the market depth, the higher the probability of execution. However, in highly volatile market conditions, the price at which an order is instantly executed may be far from the market depth, resulting in insufficient profit. On the other hand, placing orders too far away reduces the probability of execution. This is an optimization problem that needs to be addressed.

2. Position control is crucial to manage risk. A strategy cannot accumulate excessive positions for extended periods. This can be addressed by controlling the distance and quantity of orders placed, as well as setting limits on overall positions.

To achieve the above objectives, modeling and estimation are required for various aspects such as execution probabilities, profit from executions, and market estimation. There are numerous articles and papers available on this topic, using keywords such as "High-Frequency Trading" and "Orderbook." Many recommendations can also be found online, although further elaboration is beyond the scope of this article. Additionally, it is advisable to establish a reliable and fast backtesting system. Although high-frequency strategies can easily be validated through live trading, backtesting provides additional insights and helps reduce the cost of trial and error.

Required Data

Binance provides [downloadable data](https://www.binance.com/en/landing/data) for individual trades and best bid/ask orders. Depth data can be downloaded through their API by being whitelisted, or it can be collected manually. For backtesting purposes, aggregated trade data is sufficient. In this article, we will use the example of HOOKUSDT-aggTrades-2023-01-27 data.

In [1]:
```
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
```

The individual trade data includes the followings:

1. agg_trade_id: The ID of the aggregated trade.
2. price: The price at which the trade was executed.
3. quantity: The quantity of the trade.
4. first_trade_id: In cases where multiple trades are aggregated, this represents the ID of the first trade.
5. last_trade_id: The ID of the last trade in the aggregation.
6. transact_time: The timestamp of the trade execution.
7. is_buyer_maker: Indicates the direction of the trade. "True" represents a buy order executed as a maker, while a sell order is executed as a taker.

It can be seen that there were 660,000 trades executed on that day, indicating a highly active market. The CSV file will be attached in the comments section.

In [4]:
```
trades = pd.read_csv('COMPUSDT-aggTrades-2023-07-02.csv')
trades
```

Out[4]:
, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
https://stocksharp.com/file/149605
664475 rows × 7 columns

Modeling Individual Trade Amount

First, the data is processed by dividing the original trades into two groups: buy orders executed as makers and sell orders executed as takers. Additionally, the original aggregated trade data combines trades executed at the same time, at the same price, and in the same direction into a single data point. For example, if there is a single buy order with a volume of 100, it may be split into two trades with volumes of 60 and 40, respectively, if the prices are different. This can affect the estimation of buy order volumes. Therefore, it is necessary to aggregate the data again based on the transact_time. After this second aggregation, the data volume is reduced by 140,000 records.

In [6]:
```
trades['date'] = pd.to_datetime(trades['transact_time'], unit='ms')
trades.index = trades['date']
buy_trades = trades[trades['is_buyer_maker']==False].copy()
sell_trades = trades[trades['is_buyer_maker']==True].copy()
buy_trades = buy_trades.groupby('transact_time').agg({
'agg_trade_id': 'last',
'price': 'last',
'quantity': 'sum',
'first_trade_id': 'first',
'last_trade_id': 'last',
'is_buyer_maker': 'last',
'date': 'last',
'transact_time':'last'
})
sell_trades = sell_trades.groupby('transact_time').agg({
'agg_trade_id': 'last',
'price': 'last',
'quantity': 'sum',
'first_trade_id': 'first',
'last_trade_id': 'last',
'is_buyer_maker': 'last',
'date': 'last',
'transact_time':'last'
})
buy_trades['interval']=buy_trades['transact_time'] - buy_trades['transact_time'].shift()
sell_trades['interval']=sell_trades['transact_time'] - sell_trades['transact_time'].shift()
```

In [10]:
```
print(trades.shape[0] - (buy_trades.shape[0]+sell_trades.shape[0]))
```

Out [10]:
146181

Take buy orders as an example, let's first plot a histogram. It can be observed that there is a significant long-tail effect, with the majority of data concentrated towards the leftmost part of the histogram. However, there are also a few large trades distributed towards the tail end.

In [36]:
```
buy_trades['quantity'].plot.hist(bins=200,figsize=(10, 5));
```

Out [36]:
https://stocksharp.com/file/149606
For easier observation, let's trim the tail and analyze the data. It can be observed that as the trade amount increases, the frequency of occurrence decreases, and the rate of decrease becomes faster.

In [37]:
```
buy_trades['quantity'][buy_trades['quantity']<200].plot.hist(bins=200,figsize=(10, 5));
```

Out [37]:
https://stocksharp.com/file/149607
There have been numerous studies on the distribution of trade amounts. It has been found that trade amounts follow a power-law distribution, also known as a Pareto distribution, which is a common probability distribution in statistical physics and social sciences. In a power-law distribution, the probability of an event's size (or frequency) is proportional to a negative exponent of that event's size. The main characteristic of this distribution is that the frequency of large events (i.e., those far from the average) is higher than expected in many other distributions. This is precisely the characteristic of trade amount distribution. The form of the Pareto distribution is given by P(x) = Cx^(-α). Let's empirically verify this.

The following graph represents the probability of trade amounts exceeding a certain value. The blue line represents the actual probability, while the orange line represents the simulated probability. Please note that we won't go into the specific parameters at this point. It can be observed that the distribution indeed follows a Pareto distribution. Since the probability of trade amounts being greater than zero is 1, and in order to satisfy normalization, the distribution equation should be as follows:
https://stocksharp.com/file/149608
Here, N is the parameter for normalization. We will choose the average trade amount, M, and set alpha to -2.06. The specific estimation of alpha can be obtained by calculating the P-value when D=N. Specifically, alpha = log(P(d>M))/log(2). The choice of different points may result in slight differences in the value of alpha.

In [55]:
```
depths = range(0, 250, 2)
probabilities = np.array([np.mean(buy_trades['quantity'] > depth) for depth in depths])
alpha = np.log(np.mean(buy_trades['quantity'] > mean_quantity))/np.log(2)
mean_quantity = buy_trades['quantity'].mean()
probabilities_s = np.array([(1+depth/mean_quantity)**alpha for depth in depths])

plt.figure(figsize=(10, 5))
plt.plot(depths, probabilities)
plt.plot(depths, probabilities_s)
plt.xlabel('Depth')
plt.ylabel('Probability of execution')
plt.title('Execution probability at different depths')
plt.grid(True)
```

Out[55]:
https://stocksharp.com/file/149613
In [56]:
```
plt.figure(figsize=(10, 5))
plt.grid(True)
plt.title('Diff')
plt.plot(depths, probabilities_s-probabilities);
```

Out[56]:
https://stocksharp.com/file/149610
However, this estimation is only approximate, as shown in the graph where we plot the difference between the simulated and actual values. When the trade amount is small, the deviation is significant, even approaching 10%. Although selecting different points during parameter estimation may improve the accuracy of that specific point's probability, it does not solve the deviation issue as a whole. This discrepancy arises from the difference between the power-law distribution and the actual distribution. To obtain more accurate results, the equation of the power-law distribution needs to be modified. The specific process is not elaborated here, but in summary, after a moment of insight, it is found that the actual equation should be as follows:
https://stocksharp.com/file/149612
To simplify, let's use r = q/M to represent the normalized trade amount. We can estimate the parameters using the same method as before. The following graph shows that after the modification, the maximum deviation is no more than 2%. In theory, further adjustments can be made, but this level of accuracy is already sufficient.

In [52]:
```
depths = range(0, 250, 2)
probabilities = np.array([np.mean(buy_trades['quantity'] > depth) for depth in depths])
mean = buy_trades['quantity'].mean()
alpha = np.log(np.mean(buy_trades['quantity'] > mean))/np.log(2.05)
probabilities_s = np.array([(((1+20**(-depth/mean))*depth+mean)/mean)**alpha for depth in depths])

plt.figure(figsize=(10, 5))
plt.plot(depths, probabilities)
plt.plot(depths, probabilities_s)
plt.xlabel('Depth')
plt.ylabel('Probability of execution')
plt.title('Execution probability at different depths')
plt.grid(True)
```

Out[52]:
https://stocksharp.com/file/149609
In [53]:
```
plt.figure(figsize=(10, 5))
plt.grid(True)
plt.title('Diff')
plt.plot(depths, probabilities_s-probabilities);
```

Out[53]:
https://stocksharp.com/file/149611
With the estimated equation for the trade amount distribution, it is important to note that the probabilities in the equation are not the actual probabilities, but conditional probabilities. At this point, we can answer the question: What is the probability that the next order will be greater than a certain value? We can also determine the probability of orders at different depths being executed (in an ideal scenario, without considering order additions, cancellations, and queueing at the same depth).

At this point, the length of the text is already quite long, and there are still many questions that need to be answered. The following series of articles will attempt to provide answers.

From: https://blog.mathquant.c...rading-strategies-1.html

Empower Your Quantitative Trading: Unleashing the Potential of FMZ Mobile App Trading Terminal

2024-03-25T08:01:20Z

In the field of quantitative trading, simple and easy-to-use quantitative trading tools have always been one of the keys to achieving wealth growth and risk management. However, with increasing market competition, traditional trading tools are no longer sufficient to meet rapidly changing market demands. To maintain a competitive edge for quantitative traders in the constantly evolving digital asset world, FMZ Mobile App has added a significant new feature: Trading Terminal. This feature will not only improve your trading efficiency, but also empower you through custom plugin programs to assist in trading, injecting new vitality into your trading career.

Beginner's Guide to Trading Terminal:
What is the FMZ Mobile APP Trading Terminal?
On the FMZ Quant Trading Platform, you can download the FMZ Quant Mobile APP from the [Mobile App download page](https://www.fmz.com/mobile). After downloading and installing, open the FMZ mobile app and log in with your FMZ account.
https://stocksharp.com/file/149582
Please note that FMZ Quant is divided into FMZ.COM international site and FMZ.CN China domestic site (supporting different markets). When logging in, you need to choose the corresponding site. Accounts for different sites are independent and not interchangeable.

The FMZ Quantitative Trading Platform mobile APP trading terminal is a quantitative trading tool that encapsulates APIs from major exchanges. It allows quick switching between various exchanges, and with the help of various features of the FMZ platform, it can perform data capture analysis, real-time data monitoring, program-assisted trading, semi-automatic/manual trading operations etc.

How to access and enable the trading terminal function?
After logging into the FMZ Quant Mobile APP, you can see the "Trading Terminal" function on the main interface. Click to enter the trading terminal interface.

Before FMZ launched its mobile APP trading terminal, FMZ's web version had already launched this feature quite early. Whether it is a web-based trading terminal or a mobile APP-based one, **at least one docker program must be deployed**.
This is because all actual requests sent to exchanges are executed from the docker, not on the mobile app, which is safer. It also avoids disadvantages such as API KEY binding IP addresses and inability to use when mobile IP changes.
https://stocksharp.com/file/149581
Detailed Explanation of Trading Terminal Interface
**1. Main Interface of the Trading Terminal:**

After opening the trading terminal, you can see the main interface of the trading terminal. Clicking on the area in red frame will open up "Docker", "Exchange", and "Markets" configuration interfaces.

- Docker: All docker programs deployed under your current FMZ account will be listed here for selection.
- Exchange: The exchange objects (configured with API KEY information etc.) created in your current FMZ account will also appear in corresponding lists for specific operation selections.
- Markets: Set up the trading pair or contract that this trading terminal is going to operate. The input box widget for trading pairs will display selectable trading pairs/contracts based on entered information.
https://stocksharp.com/file/149583
**2. Trading Zone:**

The Trading Zone displays market depth data;
Trading widgets can be set with order price, order quantity, order direction, leverage and other settings.
https://stocksharp.com/file/149577
The bottom tabs of the main interface display information such as "Orders", "Assets", making your funds, and orders clear at a glance.

**3. K-line Chart:**

If you wish to view the K-line chart while placing an order, a thoughtful design has been implemented here - a collapsible display widget that unfolds the mini K-line chart of the current product.
https://stocksharp.com/file/149578
If you wish to view the K-line chart in a larger area, display market transaction records, depth information and more, you can click on this K-line icon to jump to the professional K-line chart page.
https://stocksharp.com/file/149576
The professional K-line chart interface:
https://stocksharp.com/file/149580
The professional K-line chart interface can also be displayed in landscape mode:
https://stocksharp.com/file/149579
Trading Plugin
What can a trading terminal plugin do?

- Real-time market data calculation and display.
- Order placement and order management.
- Implement risk management.
- Semi-automatic auxiliary trading strategies.

Which programming languages and tools are used to develop plugins?

- python
- javascript
- c++

What can you get?

- Share your plugin with the community for mutual learning with developers.
- Learn from other developers and get inspired.
- Interact with other quantitative trading enthusiasts.

Give an Example Based on a Real-life Application Scenario:
In the FMZ community, a user has put forward such a request:

> Use js to traverse all U contract currencies of the Binance exchange, and open a position of 10u (long) for each currency. How is this code written?

This requirement scenario can be implemented with trading terminal plugins actually, and running plugin strategies on the trading terminal is free of charge. Compared to long-term live trading strategies, using trading terminal plugins as an aid is undoubtedly a good choice.

Let's see how to design and implement the user's request.

Firstly, we need to create a trading terminal plugin and add three parameters to its strategy:
https://stocksharp.com/file/149592
Then start writing the plugin program:

```
function main() {
let exName = exchange.GetName()
if (exName != "Futures_Binance") {
return "not support!"
}

let apiBase = "https://fapi.binance.com"
if (isSimulate) {
apiBase = "https://testnet.binancefuture.com"
Log("Switch base address:", apiBase)
}
exchange.SetBase(apiBase)

try {
var obj = JSON.parse(HttpQuery(apiBase + "/fapi/v1/exchangeInfo"))
} catch (e) {
Log(e)
}

let pairs = []
for (var i in obj.symbols) {
if (obj.symbols[i]["status"] !== "TRADING" || obj.symbols[i]["quoteAsset"] !== "USDT") {
continue
}
let = pair = obj.symbols[i]["baseAsset"] + "_" + obj.symbols[i]["quoteAsset"]
pairs.push(pair)
}

let markets = _C(exchange.GetMarkets)
for (var i in pairs) {
// /*
// For testing purposes, only 10 varieties are opened here. If all varieties are needed, this comment content can be deleted.
if (i >= 9) {
break
}
// */

let pair = pairs[i]
exchange.SetCurrency(pair)
exchange.SetContractType("swap")
let ticker = exchange.GetTicker()
if (!ticker) {
continue
}

let = amountPrecision = markets[pair + ".swap"]["AmountPrecision"]
exchange.SetDirection("buy")
let amount = _N(qty / ticker.Last, amountPrecision)
if (amount > 0) {
exchange.Buy(-1, amount)
}

Sleep(100)
}

// Obtain all positions
let pos = exchange.IO("api", "GET", "/fapi/v2/positionRisk")
if (!pos) {
return
}

// View positions
return pos.filter(item => Number(item.positionAmt) != 0)
}
```
After the trading terminal plugin is written, it can be tested:

In the trading terminal of the mobile APP, click on the '...' button to open the list of trading terminal plugins. All plugins in the strategy library of your current FMZ account will be displayed in this list for selection and use.
https://stocksharp.com/file/149593
After completing the operation on the mobile APP, we use the following code to query the position of Binance's simulation bot:

```
function main() {
let apiBase = "https://testnet.binancefuture.com"
exchange.SetBase(apiBase)

let pos = exchange.IO("api", "GET", "/fapi/v2/positionRisk")
if (!pos) {
return
}

// View positions
return pos.filter(item => Number(item.positionAmt) != 0)
}
```
Data found:

```
[{
"symbol": "ETCUSDT",
"entryPrice": "16.17",
"unRealizedProfit": "0.08567881",
"positionSide": "LONG",
"updateTime": 1698420908103,
"isolated": false,
"breakEvenPrice": "16.176468",
"leverage": "20",
"adlQuantile": 3,
"positionAmt": "0.65",
"markPrice": "16.30181356",
"liquidationPrice": "0",
"maxNotionalValue": "400000",
"marginType": "cross",
"notional": "10.59617881",
"isolatedMargin": "0.00000000",
"isAutoAddMargin": "false",
"isolatedWallet": "0"
}, {
"positionAmt": "105",
"markPrice": "0.09371526",
"liquidationPrice": "0",
"leverage": "20",
"maxNotionalValue": "90000",
"positionSide": "LONG",
"isolatedWallet": "0",
"symbol": "TRXUSDT",
"updateTime": 1698420906668,
"breakEvenPrice": "0.094497784",
"isolatedMargin": "0.00000000",
"isolated": false,
"entryPrice": "0.09446",
"adlQuantile": 1,
"unRealizedProfit": "-0.07819770",
"isAutoAddMargin": "false",
"notional": "9.84010230",
"marginType": "cross"
}, {
"unRealizedProfit": "-0.00974456",
"isAutoAddMargin": "false",
"notional": "9.97449543",
"isolatedWallet": "0.50309216",
"updateTime": 1698420905377,
"markPrice": "67.85371047",
"isolatedMargin": "0.49334760",
"adlQuantile": 2,
"symbol": "LTCUSDT",
"entryPrice": "67.92",
"liquidationPrice": "64.91958163",
"maxNotionalValue": "250000",
"positionSide": "LONG",
"isolated": true,
"positionAmt": "0.147",
"breakEvenPrice": "67.947168",
"leverage": "20",
"marginType": "isolated"
}, {
"liquidationPrice": "1613.23261508",
"marginType": "isolated",
"isolated": true,
"symbol": "ETHUSDT",
"entryPrice": "1784.27",
"markPrice": "1783.35661952",
"isAutoAddMargin": "false",
"positionSide": "LONG",
"notional": "8.91678309",
"leverage": "10",
"maxNotionalValue": "30000000",
"isolatedWallet": "0.89551774",
"adlQuantile": 1,
"positionAmt": "0.005",
"breakEvenPrice": "1784.983708",
"unRealizedProfit": "-0.00456690",
"isolatedMargin": "0.89095084",
"updateTime": 1698420900362
}, {
"positionAmt": "17.1",
"marginType": "cross",
"isolatedWallet": "0",
"adlQuantile": 2,
"liquidationPrice": "0",
"maxNotionalValue": "250000",
"positionSide": "LONG",
"isolated": false,
"symbol": "EOSUSDT",
"breakEvenPrice": "0.6432572",
"updateTime": 1698420904257,
"isolatedMargin": "0.00000000",
"isAutoAddMargin": "false",
"notional": "10.34550000",
"entryPrice": "0.643",
"markPrice": "0.60500000",
"unRealizedProfit": "-0.64980000",
"leverage": "20"
}, {
"isolated": false,
"adlQuantile": 1,
"liquidationPrice": "0",
"maxNotionalValue": "10000000",
"notional": "9.73993328",
"leverage": "20",
"updateTime": 1698420901638,
"symbol": "BCHUSDT",
"entryPrice": "250.0",
"markPrice": "243.49833219",
"isAutoAddMargin": "false",
"positionSide": "LONG",
"positionAmt": "0.040",
"breakEvenPrice": "250.1",
"isolatedMargin": "0.00000000",
"unRealizedProfit": "-0.26006671",
"marginType": "cross",
"isolatedWallet": "0"
}]
```
It can be seen that 6 positions have been opened, this is because when placing actual orders on the simulation bot, it's easy to trigger limit prices; in addition, due to the order amount of 10U, it's easy to trigger the minimum order amount limit of trading pairs; therefore a few trading pairs were not successfully ordered.
If you need to use this in reality, more practical situations should be considered in order to optimize this plugin for better usage. The code here is only used for teaching and communication purposes.

Other Interesting Built-in Plugins on FMZ
The FMZ Quant Trading Platform mobile app trading terminal has many interesting plugins. Come and explore together!

https://www.fmz.com/uplo...6b436307a4ce5c246c2.mp4

The End
The new trading terminal feature of the FMZ mobile app will become your powerful assistant in the digital asset market, allowing you to respond more flexibly to market fluctuations and opportunities. No longer limited to traditional trading strategies, through custom plugin programs, you can create smarter, more efficient trading strategies that are better adapted to the market. Let's start this exciting new chapter of quantitative trading together and enhance your trading skills and profits.

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

Navigating Position Risk: Unveiling VaR Method for Effective Measurement

2024-03-25T05:16:19Z

Controlling risk is a skill that every investor needs to learn. With the rapidly changing and evolving cryptocurrency market, algorithmic traders need to focus on risk management especially. This is because algorithmic trading often executes trades automatically based on historical data and statistical models, which may quickly become inaccurate in fast-moving markets. Therefore, effective risk management strategies are crucial for protecting investors' capital.

Among many risk management tools, Value at Risk (VaR) is a widely used measure of risk. It can help investors predict the maximum loss that might occur under normal market conditions in their portfolio. VaR quantifies risk into a single number, simplifying the expression of risk and allowing investors to understand potential losses intuitively.

The Role of VaR
VaR, or "Value at Risk", is used to quantify the maximum possible loss that can be endured within a certain period of time, according to a certain confidence level. In other words, it tells investors or risk managers: "Under normal market conditions, how much money is within the 'safe' range and will not be lost tomorrow." For example, if the 1-day 99% VaR of a cryptocurrency portfolio is $10,000, it means that in 99% of cases we expect the loss in one day will not exceed $10,000.

Advantages
1. **Easy to understand** : For example, the 1-day 95% VaR of a digital currency portfolio is $5000, which means there is a 95% confidence that the loss of the portfolio within one day will not exceed $5000. Quantifying complex risks into an intuitive number makes it easy for non-professionals to understand. Of course, it's inevitably to have some misleading aspects.

2. **Relatively standard** : Suppose there are two portfolios A and B, with A's 1-day 95% VaR being $3000 and B's being $6000. This implies that under normal market conditions, A's risk is lower than B's. Even if these two portfolios contain different assets, we can compare their risk levels directly. Correspondingly, we can also judge the level of investment; if both strategies A and B have earned $6000 in the past month but A's average and maximum VaR values are significantly lower than B's, then we could consider strategy A as better, since it achieves higher returns at a lower risk level.

3. **Decision-making tool** : Traders might use VaR to decide whether or not to add a new asset to their portfolio. If adding an asset increases the VaR value significantly, then it may suggest that the added asset's risk does not match with the portfolio's acceptable risk level.

Disadvantages
1. **Ignoring tail risk** : If a portfolio's 1-day 99% VaR is $10,000, the loss in the extreme 1% scenario could far exceed this value. In the field of digital currency, black swan events are frequent and extreme situations can exceed most people's expectations, because VaR does not consider tail events.

2. **Assumption limitations** : The parameter VaR often assumes that asset returns are normally distributed, which is rarely the case in real markets, especially in digital currency markets. For example, suppose a portfolio only contains Bitcoin. We use the parameter VaR and assume that Bitcoin's return is normally distributed. However, in reality, Bitcoin's rate of return may experience large jumps during certain periods and exhibit significant volatility clustering phenomena. If there has been high volatility over the past week, the probability of noticeable volatility in the following period will increase significantly. This can lead to an underestimation of risk by normal distribution models. Some models take this issue into account such as GARCH etc., but we won't discuss them here.

3. **Historical dependence** : The VaR model relies on historical data to predict future risks. However, past performance does not always indicate future situations, especially in rapidly changing markets like the digital currency market. For example, if Bitcoin has been very stable over the past year, a historical simulation might predict a very low VaR. However, if there is a sudden regulatory change or market crash, past data will no longer be an effective predictor of future risk.

Methods of Calculating VaR
There are mainly three methods to calculate VaR: Parametric method (Variance-Covariance Method): This assumes that the rate of return follows a certain distribution (usually normal distribution), and we use the mean and standard deviation of the rate of return to calculate VaR. Historical Simulation Method: It makes no assumptions about the distribution of returns, but uses historical data directly to determine potential loss distributions. Monte Carlo Simulation: It uses randomly generated price paths to simulate asset prices and calculates VaR from them.

The Historical Simulation Method utilizes past price changes directly to estimate possible future losses. It does not need any assumptions about profit distribution, making it suitable for assets with unknown or abnormal profit distributions, such as digital currencies.

For example, if we want to calculate 1-day 95% VaR for a Bitcoin spot position, we can do this:

1. Collect the daily returns of Bitcoin over a certain period (for example, 100 days).
2. Calculate the portfolio return rate each day, which is the return rate of each asset multiplied by its weight in the portfolio.
3. Sort these 100 days of portfolio returns from low to high.
4. Find the data point at the 5% mark (because we are calculating 95% VaR). The point represents the loss rate on the best day out of worst five days in past 100 days.
5. Multiply the return by total value held, and that's your one-day 95% VaR.

The following is a specific code that has obtained data from the past 1000 days, calculating that the current VaR for holding one BTC spot is 1980 USDT.

```
import numpy as np
import requests

url = 'https://api.binance.com/api/v3/klines?symbol=%s&interval=%s&limit=1000'%('BTCUSDT','1d')
res = requests.get(url)
data = res.json()

confidence_level = 0.95
closing_prices = [float(day[4]) for day in data]
log_returns = np.diff(np.log(closing_prices))
VaR = np.percentile(log_returns, (1 - confidence_level) * 100)
money_at_risk = VaR * closing_prices[-1] * 1

print(f"VaR at {confidence_level*100}% confidence level is {money_at_risk}")
```
Calculating VaR Considering Correlation
When calculating the VaR of a portfolio containing multiple assets, we must consider the correlation between these assets. If there is a positive correlation in price changes between assets, then the risk of the portfolio will increase; if it's negatively correlated, then the risk of the portfolio will decrease.

When using historical simulation method to calculate VaR considering correlation, we need to collect not only each individual asset's historical returns, but also consider their joint distribution. In practice, you can use the historical returns of your portfolio for sorting and calculation directly, because these returns already implicitly include inter-asset correlations. In cryptocurrency markets, correlation is especially important with BTC essentially leading market trends. If BTC rises bullishly, other cryptocurrencies are likely to rise as well; if BTC rapidly surges or plummets due to quickly changing market, this could cause significant short-term increases in correlation - something that is particularly common during extreme market events. Therefore, historical simulation method is a useful tool when considering digital currency investment portfolios' VaR calculations. It doesn't require complex statistical models - just effective historical data - and naturally includes inter-asset correlations.

For example: holding 1 long position on BTC and 10 short positions on ETH – following our previous method – we can calculate that 10 ETH short positions have a VaR of 1219 USDT. When combining these two types of assets into one portfolio, here's how you would calculate its combined VaR:

```
confidence_level = 0.95
btc_closing_prices = np.array([float(day[4]) for day in btc_data])
eth_closing_prices = np.array([float(day[4]) for day in eth_data])
btc_log_returns = np.diff(np.log(btc_closing_prices))
eth_log_returns = np.diff(np.log(eth_closing_prices))

log_returns = (1*btc_log_returns*btc_closing_prices[1:] - 10*eth_log_returns*eth_closing_prices[1:])/(1*btc_closing_prices[1:] + 10*eth_closing_prices[1:])
VaR = np.percentile(log_returns, (1 - confidence_level) * 100)
money_at_risk = VaR * (btc_closing_prices[-1] * 1 + eth_closing_prices[-1]*10)

print(f"VaR at {confidence_level*100}% confidence level is {money_at_risk}")
```
The result is 970 USDT, which means the risk of this combination is lower than holding the respective assets separately. This is because BTC and ETH markets have a high correlation, and the hedging effect of long-short position combinations serves to reduce risk.

Summary
This article will introduce a highly adaptive risk assessment method, namely the application of Historical Simulation in calculating VaR, as well as how to consider asset correlations to optimize risk prediction. Through specific examples from the digital currency market, it explains how to use historical simulation to assess portfolio risks and discusses methods for calculating VaR when asset correlations are significant. With this method, algorithmic traders can not only estimate their maximum loss in most situations, but also be prepared for extreme market conditions. This allows them to trade more calmly and execute strategies accurately.

From: https://blog.mathquant.c...n-to-the-var-method.html

Exploring Unconventional Trading Techniques: The K-Line Area Trading Strategy

2024-03-25T03:03:22Z

Looking at a not-so-reliable trading idea -- the K-line area trading strategy, in this article, we will explore the concept and try to implement the script.

Main Idea of the K-Line Area Strategy
The K-line area strategy is a trading strategy based on the area relationship between price K-lines and moving averages. Its main idea is to predict possible trends in stock prices by analyzing the magnitude and changes of price trends, as well as shifts in buying and selling sentiment, thereby determining when to open positions and exit. This strategy relies on the area between the K-line and moving averages, as well as values from the KDJ indicator, to generate long and short trading signals.

The Principle of K-Line Area Strategy
The area of the K-line refers to the spatial area between the price K-line and the moving average, calculated by subtracting the moving average value from each bar's closing price and then summing it up. When there is a large increase in price over a long period of time, the K-line area will become larger, while during volatile markets or after volatility reversals, the K-line area is smaller. According to the principle of "what goes up must come down", as an upward trend becomes larger and lasts longer, its corresponding K-line area also increases; thus increasing its probability for reversal - much like a spring that rebounds with greater force when stretched further. Therefore, setting a threshold for this K-line area can indicate when prices may have reached their peak and are likely to reverse.

To further confirm an impending trend reversal, we introduce the use of KDJ indicators which help determine shifts in buying or selling sentiment. The thresholds for the strategy and values for these indicators can be adjusted according to specific circumstances and needs in order to enhance accuracy.

The Advantages of K-Line Area Strategy
The advantage of the K-line area strategy lies in its combination of the magnitude and changes of price trends, as well as the shift in buying and selling sentiment, providing a relatively complete quantitative trading strategy. Its advantages include:

- It provides a simple and intuitive method to identify the possibility of trend reversal, helping traders better grasp market trends.
- By combining the K-line area and KDJ indicator, it increases the reliability and accuracy of the strategy.
- High flexibility allows for parameter adjustments according to market conditions to meet different trading needs.

Risk of K-line Area Strategy
Although the K-line area strategy has certain advantages, it also carries some risks, including:

- The setting of thresholds may require some experience and adjustment. If it set improperly, it could lead to misjudgment of market trends.
- The accuracy of the KDJ indicator is affected by market fluctuations and noise, which may result in false signals.
- The performance of the strategy may vary under different market conditions and needs constant optimization and adjustment.

Optimization Direction of K-line Area Strategy
To optimize the K-line area strategy, consider the following directions:

- Parameter optimization: Continuously adjust and optimize threshold values and KDJ indicator parameters to adapt to different market conditions and trading needs.
- Risk management: Implement effective risk management strategies, including stop-loss and take-profit rules, to reduce loss risks.
- Multi-strategy combination: Combine the K-line area strategy with other strategies to improve the performance of comprehensive trading strategies.
- Real-time monitoring and adjustment: Regularly monitor the performance of strategies, adjusting and improving based on actual situations.

Implement the Strategy Using JavaScript
- Calculate K-line Area

- Long position opening signal:

(1) The "K-line area" of the downward trend reaches the threshold, it can be established beforehand.

(2) KDJ indicator value is greater than 80.

- Short position opening signal:

(1) The "K-line area" of the upward trend reaches the threshold, it can be established beforehand.

(2) KDJ indicator value is less than 20.

- Exit for Long/Short positions: ATR trailing stop loss and take profit.

Code implementation

```
// Parameter
var maPeriod = 30
var threshold = 50000
var amount = 0.1

// Global variable
let c = KLineChart({})
let openPrice = 0
let tradeState = "NULL" // NULL BUY SELL

function calculateKLineArea(r, ma) {
var lastCrossUpIndex = null
var lastCrossDownIndex = null
for (var i = r.length - 1 ; i >= 0 ; i--) {
if (ma[i] !== null && r[i].Open < ma[i] && r[i].Close > ma[i]) {
lastCrossUpIndex = i
break
} else if (ma[i] !== null && r[i].Open > ma[i] && r[i].Close < ma[i]) {
lastCrossDownIndex = i
break
}

if (i >= 1 && ma[i] !== null && ma[i - 1] !== null && r[i - 1].Close < ma[i - 1] && r[i].Close > ma[i]) {
lastCrossUpIndex = i
break
} else if (i >= 1 && ma[i] !== null && ma[i - 1] !== null && r[i - 1].Close > ma[i - 1] && r[i].Close < ma[i]) {
lastCrossDownIndex = i
break
}
}

var area = 0
if (lastCrossDownIndex !== null) {
for (var i = r.length - 1 ; i >= lastCrossDownIndex ; i--) {
area -= Math.abs(r[i].Close - ma[i])
}
} else if (lastCrossUpIndex !== null) {
for (var i = r.length - 1 ; i >= lastCrossUpIndex ; i--) {
area += Math.abs(r[i].Close - ma[i])
}
}

return [area, lastCrossUpIndex, lastCrossDownIndex]
}

function onTick() {
var r = _C(exchange.GetRecords)
if (r.length < maPeriod) {
LogStatus(_D(), "Insufficient number of K-line")
return
}
var ma = TA.MA(r, maPeriod)
var atr = TA.ATR(r)
var kdj = TA.KDJ(r)
var lineK = kdj[0]
var lineD = kdj[1]
var lineJ = kdj[2]
var areaInfo = calculateKLineArea(r, ma)
var area = _N(areaInfo[0], 0)
var lastCrossUpIndex = areaInfo[1]
var lastCrossDownIndex = areaInfo[2]

r.forEach(function(bar, index) {
c.begin(bar)
c.plotcandle(bar.Open, bar.High, bar.Low, bar.Close, {overlay: true})
let maLine = c.plot(ma[index], "ma", {overlay: true})
let close = c.plot(bar.Close, 'close', {overlay: true})
c.fill(maLine, close, {color: bar.Close > ma[index] ? 'rgba(255, 0, 0, 0.1)' : 'rgba(0, 255, 0, 0.1)'})
if (lastCrossUpIndex !== null) {
c.plotchar(bar.Time, {char: '$:' + area, overlay: true})
} else if (lastCrossDownIndex !== null) {
c.plotchar(bar.Time, {char: '$:' + area, overlay: true})
}
c.plot(lineK[index], "K")
c.plot(lineD[index], "D")
c.plot(lineJ[index], "J")

c.close()
})

if (tradeState == "NULL" && area < -threshold && lineK[lineK.length - 1] > 70) {
// long
let tradeInfo = $.Buy(amount)
if (tradeInfo) {
openPrice = tradeInfo.price
tradeState = "BUY"
}
} else if (tradeState == "NULL" && area > threshold && lineK[lineK.length - 1] < 30) {
// short
let tradeInfo = $.Sell(amount)
if (tradeInfo) {
openPrice = tradeInfo.price
tradeState = "SELL"
}
}

let stopBase = tradeState == "BUY" ? Math.max(openPrice, r[r.length - 2].Close) : Math.min(openPrice, r[r.length - 2].Close)
if (tradeState == "BUY" && r[r.length - 1].Close < stopBase - atr[atr.length - 2]) {
// cover long
let tradeInfo = $.Sell(amount)
if (tradeInfo) {
tradeState = "NULL"
openPrice = 0
}
} else if (tradeState == "SELL" && r[r.length - 1].Close > stopBase + atr[atr.length - 2]) {
// cover short
let tradeInfo = $.Buy(amount)
if (tradeInfo) {
tradeState = "NULL"
openPrice = 0
}
}

LogStatus(_D(), "area:", area, ", lineK[lineK.length - 2]:", lineK[lineK.length - 2])
}

function main() {
if (exchange.GetName().includes("_Futures")) {
throw "not support Futures"
}
while (true) {
onTick()
Sleep(1000)
}
}
```
The strategy logic is very simple:

1. First, some global variables and parameters are defined, including:

Strategy parameters

- maPeriod: The period of moving average.
- threshold: A threshold used to determine the timing of buying or selling.
- amount: The quantity for each transaction.

Global variables

- c: A K-line chart object, used for drawing charts.
- openPrice: Records the opening price.
- tradeState: Records the trading status, which can be "NULL" (empty position), "BUY" or "SELL".

Calculate function

- calculateKLineArea function: It is used to calculate the area between the price and moving average line on a K-line chart over a certain period of time, and returns the area value, the index of the last upward crossing K-line, and the index of the last downward crossing K-line. These values are used in subsequent decisions to determine when to buy and sell.

Main loop function

- onTick function: It is the main strategy execution function, and here are the operations within the function:

a. Obtain the latest K-line data and ensure that the number of K-lines is not less than maPeriod, otherwise record status and return.

b. Calculate moving average line ma and ATR indicator atr, as well as KDJ indicator.

c. Get area information from areaInfo, last cross-over K-line index, and last cross-under K-line index.

d. Use K-line chart object c to draw K-lines and indicator lines while filling in different colors based on price's relationship with moving average line.

e. Determine buying or selling timing according to conditions:

If tradeState is "NULL", and the area is less than -threshold, and the K value of KDJ is greater than 70, execute a buy operation.
If tradeState is "NULL", and the area is greater than threshold, and the K value of KDJ is less than 30, execute a sell operation.
f. Set stop loss and take profit conditions. If these conditions are met, close positions:

If it's in buying state, when the price falls below the closing price of last trading day minus previous day's ATR (Average True Range), close position.
If it's in selling state, when the price rises above last trading day's closing price plus previous day's ATR (Average True Range), close position.

main function: This serves as main execution entry point. It checks if exchange name contains "_Futures". If so, an exception will be thrown; otherwise it enters into an infinite loop where onTick function gets executed every second.

In a word, this strategy mainly relies on K-line charts and technical indicators for making buying or selling decisions while also employing stop-loss & take-profit strategies to manage risk. Please note that this just serves as an example strategy which needs to be adjusted & optimized according to market situations & specific requirements during actual use.

On FMZ.COM, using JavaScript language didn't require many lines of code, instead, it implemented this model easily. And with help from KLineChart function graphical representation of K-line chart area was easily achieved, too. The strategy design caters towards cryptocurrency spot markets by utilizing 'Digital Currency Spot Trading Library' template for placing orders through encapsulated functions within template, which makes it very simple & easy to understand and use.

Strategy Backtesting
https://stocksharp.com/file/149572
https://stocksharp.com/file/149571
I selected a backtesting period randomly. Although I didn't lose money, I didn't accumulate profits continuously, either, and the drawdown issue is quite significant. There should be other directions and room for optimization for the strategy. Those who are interested can try to upgrade the strategy.
https://stocksharp.com/file/149569
https://stocksharp.com/file/149570
Through the strategy, we not only learned a rather unconventional trading idea, but also learned how to plot diagrams; representing the area enclosed by K-line and moving average line; ploting KDJ indicators etc.

Summary
The K-line area strategy is a trading strategy based on price trend magnitude and the KDJ indicator. It helps traders predict market trends by analyzing the area between the K-line and moving averages, as well as shifts in buying and selling sentiment. Despite certain risks, this strategy can provide powerful trading tools through continuous optimization and adjustment, helping traders better cope with market fluctuations. Moreover, traders should adjust the parameters and rules of the strategy flexibly according to specific situations and market conditions to achieve better trading performance.

From: https://blog.mathquant.c...ea-trading-strategy.html

High-Frequency Trading Strategy Analysis - Penny Jump

2024-03-25T01:14:50Z

High-frequency trading is a challenging and competitive field that relies on rapid trade execution and sensitive insights into the microstructure of the market. One notable strategy is Penny Jump, which focuses on exploiting "elephants" in the market to gain small but frequent profits. In this article, we will explain in detail how the Penny Jump strategy works, delving into the details of its code, so that beginners can understand how it operates.

Understanding the Penny Jump Strategy
In the stock market, "elephants" usually refer to those institutional investors who wish to buy or sell a large number of shares but are unwilling to trade at market price. Instead, they choose to hang a large number of limit orders in the market, i.e., pending orders, to indicate their intentions. This behavior has attracted widespread attention in the market, because large transactions may have a significant impact on the market.

For example, suppose the original depth of a stock's market was like this: 200 | $1.01 x $1.03 | 200. Then an "elephant" enters and places a buy order for 3000 shares at $1.01 each. At this point, the depth of the market will change to 3,200 | $1.01 x $1.03 | 200 . This action is like introducing an "elephant", which becomes the focus of other participants in the marketplace.

- Competitive market
For high-frequency traders, their profits mainly come from the analysis of market microstructure to speculate on the intentions of other traders. Once a big player appears, high-frequency traders will establish positions quickly to capture minor price fluctuations. Their goal is to trade frequently in a short period of time and accumulate small but cumulative profits.

- The Dilemma of the Elephant
Even though elephants might wish to operate on a large scale in the market, their actions also reveal their trading intentions, making them targets for high-frequency traders. High-frequency traders attempt to establish positions ahead of time and then profit from price fluctuations. The presence of elephants in the market could trigger reactions in competitive markets, thereby affecting their trading strategies.

- Deception in the Market
In reality, large institutional investors usually do not place a large number of buy or sell orders in the market blatantly, as such behavior could lead other participants in the market to take countermeasures or even manipulate the market. Therefore, they may adopt strategies to create illusions, attract high-frequency traders into the field, and then quickly sell or buy to profit from price fluctuations.

The Core Idea of the Penny Jump Strategy
The core idea of the Penny Jump strategy is that once a "big player" appears in the market and supports a specific price (such as $1.01), high-frequency traders will quickly raise their bid by one cent, for instance, to $1.02. This is because high-frequency traders understand that the appearance of a big player means there's strong buying support at this price level, so they try to follow closely in hopes of a price increase. When the price indeed rises to $1.03 x $1.05, high-frequency traders can sell quickly and earn a profit of $0.01.

Not only that, but high-frequency traders can also make profits after purchasing even if the price doesn't rise, because they know that the big player has supported the base price; hence they can swiftly sell their stocks to this big player and gain tiny arbitrage profits.

Analyzing Penny Jump Strategy Code
Strategy source code: https://www.fmz.com/strategy/358

The strategy code provided above is an example, used to implement the Penny Jump strategy. Below is a detailed explanation of the code, enabling beginners to understand how it works:

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

// Variables
var InitAccount = null;

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

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

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

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

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

```
var Counter = {
i: 0,
w: 0,
f: 0
};
```
This code initializes an object named Counter, which is used to track the trading statistical information of a strategy. Specifically, it includes three attributes:

- i: Represents the total number of transactions.
- w: Represents the number of successful transactions.
- f: Represents the number of failed transactions.

These attributes will be recorded and updated during the strategy execution process.

```
var InitAccount = null;
```
This line of code initializes a variable named InitAccount, which will store account information when the strategy starts executing.

```
function CancelAll() {
while (true) {
var orders = _C(exchange.GetOrders);
if (orders.length == 0) {
break;
}
for (var i = 0; i < orders.length; i++) {
exchange.CancelOrder(orders[i].Id);
}
Sleep(Interval);
}
}
```
This is a function named ```CancelAll()```, its purpose is to cancel all unfulfilled orders in the market. Let's explain its functions step by step:

- ```while (true)```: This is an infinite loop, it will continue to run until there are no uncompleted orders.
- ```var orders = _C(exchange.GetOrders)```: This line of code uses the exchange.GetOrders function to retrieve all pending orders in the current account and stores them in the orders variable.
- ```if (orders.length == 0)```: This line of code checks for any unfinished orders. If the length of the orders array is 0, it means there are no unfinished orders and the loop will be interrupted (break).
- ```for (var i = 0; i < orders.length; i++)```: This is a for loop that iterates through all uncompleted orders.
- ```exchange.CancelOrder(orders[i].Id)```: This line of code uses the exchange.CancelOrder() function to cancel each order by its ID.
- ```Sleep(Interval)```: This line of code introduces a waiting period, pausing for a certain amount of time (in milliseconds), to ensure that the operation of cancelling orders is not too frequent.

This line of code introduces a waiting period, pausing for a certain amount of time (in milliseconds), to ensure that the operation of cancelling orders is not too frequent.

```
function updateStatus(msg) {
LogStatus("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", Counter.f, "\n" + msg + "#0000ff\n" + new Date());
}
```
This is a function named ```updateStatus(msg)```, which is used to update and record transaction status information. It accepts a msg parameter, which usually contains information about the current market status. The specific operations of the function include:

Using the ```LogStatus()``` function to record the information displayed in the status bar during strategy execution. It displays text about trade counts, successful counts, and failure counts.
The ```msg``` parameter is appended, which contains information about the current market status.
The current timestamp (```new Date()```) is appended to display time information.
The purpose of this function is to record and update transaction status information for monitoring and analysis during strategy execution.

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

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

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

- ```if (DisableLog)```: This line of code checks if the DisableLog variable is true, and if so, it will disable log recording. This is to ensure that unnecessary logs are not recorded by the strategy.

- ```CancelAll()```: Call the previously explained CancelAll() function to ensure that there are no unfinished orders.

- ```InitAccount = _C(exchange.GetAccount)```: This line of code retrieves the current account information and stores it in the InitAccount variable. This will be used to record the account status when the strategy starts executing.

- ```var i = 0; ``` and ``` var locks = 0;```: Initialize two variables, i and locks, which will be used in the subsequent strategy logic.

- ```while (true)```: This is an infinite loop, mainly used for the continuous execution of strategies.

Next, we will explain the main strategy logic within the ```while (true)``` loop line by line.

```
while (true) {
Sleep(Interval);
var depth = _C(exchange.GetDepth);
if (depth.Asks.length === 0 || depth.Bids.length === 0) {
continue;
}
updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ", Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);
```
- ```Sleep(Interval)```: This line of code allows the strategy to sleep for a period of time, in order to control the execution frequency of the strategy. The Interval parameter defines the sleep interval (in milliseconds).

- ```var depth = _C(exchange.GetDepth)```: Obtain the current market depth information, including the prices and quantities of sell orders and buy orders. This information will be stored in the depth variable.

- ```if (depth.Asks.length === 0 || depth.Bids.length === 0)```: This line of code checks the market depth information, ensuring that both sell orders and buy orders exist. If one of them does not exist, it indicates that the market may not have enough trading information, so the strategy will continue to wait.

- ```updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ", Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks)```: This line of code calls the updateStatus function to update the status information of the strategy. It records the current market status, including the highest bid price, lowest ask price and previously locked times (locks).

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

```
- ```var askPrice = 0;```: Initialize the askPrice variable, it will be used to store the price of sell orders that meet the conditions.

- ```for (i = 0; i < depth.Asks.length; i++)```: This is a for loop used to traverse the price and quantity information of market sell orders.

- ```if (depth.Asks[i].Amount >= Lot)```: In the loop, check if the quantity of each sell order is greater than or equal to the specified Lot (hand count). If so, store the price of that sell order in askPrice and terminate the loop.

- ```if (askPrice === 0)```: If no sell orders that meet the conditions are found (askPrice is still 0), the strategy will continue to wait and skip subsequent operations.

- ```var elephant = null;```: Initialize the elephant variable, it will be used to store the buy order information identified as "elephant".

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

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

```
Continue to traverse the price and quantity information of market buy orders, skipping the first buy order (Bids[0]).

- ```if ((askPrice - depth.Bids[i].Price) > ElephantSpace)```: Check whether the gap between the current bid price and askPrice is greater than ElephantSpace. If so, it indicates that it is far enough from the "elephant", and the strategy will no longer continue to search.

- ```if (depth.Bids[i].Amount >= ElephantAmount)```: Check if the quantity of the current buy order is greater than or equal to ElephantAmount. If so, store the buy order information in the elephant variable.

- ```if (!elephant)```: If the "elephant" is not found, reset the lock count to 0 and continue waiting.

- ```locks++```: If the "elephant" is found, increment the lock count. This is to ensure that the strategy is executed only after confirming the existence of the "elephant" multiple times over a period of time.

- ```if (locks < LockCount)```: Check whether the number of lock times has met the requirement (LockCount). If it hasn't, continue to wait.

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

```
- ```updateStatus("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant))```: Call the updateStatus function to record the current status of the strategy, including the gear position of the "elephant" found and related information. This will be displayed in the status bar of the strategy.

- ```exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant)```: Use the exchange.Buy function to purchase the found "elephant". The purchase price is elephant.Price + PennyTick, the purchase quantity is Lot, and describe the purchase operation as "Bids[" + i + "]".

- ```var ts = new Date().getTime()```: Obtain the timestamp of the current time for subsequent calculation of time intervals.

- ```while (true)```: Enter a new infinite loop, used to wait for the execution of "elephant" buy orders.

- ```Sleep(CheckInterval)```: The strategy sleeps for a while to control the frequency of checking order status.

- ```var orders = _C(exchange.GetOrders)```: Obtain all order information of the current account.

- ```if (orders.length == 0)```: Check if there are any unfinished orders, if not, break the loop.

- ```(new Date().getTime() - ts) > WaitInterval```: Calculate the time interval between the current time and when the "elephant" was purchased. If it exceeds WaitInterval, it means that the waiting has timed out.

- ```for (var i = 0; i < orders.length; i++)```: Traverse through all uncompleted orders.

- ```exchange.CancelOrder(orders[i].Id)```: Use the exchange.CancelOrder function to cancel each unfinished order.

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

```
- ```var account = _C(exchange.GetAccount)```: Obtain current account information.

- ```var opAmount = _N(account.Stocks - InitAccount.Stocks)```: Calculate the change in account assets after purchasing the "elephant". If the change is less than 0.001, it indicates that the purchase has failed, increase the number of failures and continue to the next loop.

- ```updateStatus("Successful payment: " + opAmount + ", Start taking action...")```: Record the successful purchase information of "elephant", including the quantity purchased.

- ```exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount)```: Use the exchange.Sell function to sell the successfully purchased "elephant" for profit. The selling price is elephant.Price + (PennyTick * ProfitTick).

Enter a new infinite loop, used to wait for the execution of sell orders.

- ```var depth = _C(exchange.GetDepth)```: Obtain market depth information.

- ```if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick)))```: Check the market depth information, if the market price has already fallen to the stop-loss level, then execute the stop-loss operation.

- ```CancelAll()```: Call the CancelAll() function to cancel all uncompleted orders, in order to avoid position risk.

- ```if (opAmount < 0.001)```: Check the purchase quantity again, if it's less than 0.001, it indicates that the purchase has failed, break out of the loop.

- ```exchange.Sell(depth.Bids[0].Price, opAmount)```: Execute a stop-loss operation, sell the remaining assets at the current market's lowest price.

Finally, update the number of successful and failed transactions based on whether the transaction was successful or not, and record the trading profits.

This is a line-by-line explanation of the entire strategy. The core idea of this strategy is to find "elephants" (large buy orders) in the market, buy and sell them to gain small profits. It includes several important parameters, such as Lot, error retry interval (Interval), ElephantAmount, ElephantSpace, etc., to adjust the strategy.

In general, this strategy is a high-frequency trading strategy aimed at utilizing market depth information to identify large buy orders and carry out buying and selling transactions in a short period. It needs constant monitoring of the market and execution of buying and selling operations to quickly gain small profits. However, it's also a high-risk strategy, because it requires quick responses to market fluctuations while considering risk management and stop-loss mechanisms to avoid significant losses.

Please note that the strategy is based on specific markets and trading platforms. For different markets and exchanges, appropriate adjustments and optimizations may be needed. In practical application, investors need to carefully test and evaluate the performance of the strategy to ensure it aligns with their investment goals and risk tolerance.

As you continue to execute the strategy, it will repeatedly perform the following operations:

1. Firstly, the strategy will check the depth information of the market to understand the current situation of sell orders and buy orders.

2. Next, the strategy will attempt to find sell orders that meet the criteria, specifically sell orders with a quantity greater than or equal to Lot. If a qualifying sell order is found, the price of the sell order will be recorded as askPrice.

3. Then, the strategy will continue to search for "elephants" (large amount of buy orders). It will traverse through the market's buy orders, skipping the first one (usually the highest-priced buy order). If it finds an "elephant" that meets the criteria, it will record information about the "elephant", and increase locks.

4. If a sufficient number of "elephants" are found consecutively (controlled by the LockCount parameter), the strategy will further perform the following operations:

- Call the updateStatus function to record the gear and related information of the "elephant".
- Use the exchange.Buy function to purchase an "elephant", with a purchase price of elephant.Price + PennyTick, and a quantity of Lot.
- Start a new infinite loop for waiting for execution of the buy order.
- Check order status. If it is completed, break out from loop.
- If waiting time exceeds set interval (WaitInterval), cancel all uncompleted orders.
- Calculate changes in account assets after successful purchase. If change is less than 0.001, it indicates that purchase failed; increase failure count and continue next loop.
- Record information about successful purchases of "elephants", including quantity purchased.

5. Next, the strategy will continue to enter a new infinite loop, waiting for the execution of sell operations. In this loop, it will perform the following actions:
- Obtain market depth information, check if the market price has already reached the stop-loss level.
- If the market price has reached or fallen below the stop-loss level, a stop-loss operation will be executed, that is, the remaining assets will be sold.
- Call the CancelAll function to cancel all uncompleted orders, reducing position risk.
- Recheck the change in account assets after a successful purchase. If the change is less than 0.001, it indicates that the purchase has failed and exit the loop.
- Finally, record whether the transaction is successful or not, and update the number of successes and failures based on the transaction results.

The entire strategy continuously carries out the above operations to capture as many "elephants" as possible and obtain small profits. This is a high-frequency trading strategy that requires quick responses to market changes, while also considering risk management and stop-loss mechanisms to protect capital. Investors should carefully consider using this strategy, especially in highly volatile markets.

Summary
The Penny Jump strategy is a typical example in high-frequency trading, demonstrating the subtle game and competition among market participants. This strategy is particularly prominent in the cryptocurrency market due to its large fluctuations, where institutional investors and high-frequency traders are all pursuing quick profits. However, this also makes the market full of challenges, requiring constant adaptation and adjustment of strategies to maintain competitive advantages. In this fiercely competitive world, only those traders who are good at discerning the microstructure of the market and responding quickly can achieve success.

From: https://blog.mathquant.c...analysis-penny-jump.html

The Evolution of PSY Factor: Upgrading and Transforming for Enhanced Trading Strategies

2024-03-21T09:11:50Z

Welcome all traders to my channel, I am a Quant Developer, specializing in full-stack development of CTA, HFT & Arbitrage trading strategies.
Thanks to the FMZ Platform, I will share more content related to quantitative development and work together with all traders to maintain the prosperity of the quant community.

Today, I will bring you an upgrade and transformation of the PSY (Psychological Line) factor. We will show how to add more market information from a simple factor perspective, step by step transform it, and ultimately turn it into a powerful factor with explanatory and logical strength!!! Of course, after reading this article, you can incorporate the transformed PSY factor into your own library of factors as a powerful weapon~

> PART1 Initial PSY Factor

The PSY Factor (Psychological Line) is a technical analysis indicator used to measure the impact of market participants' emotions on price trends. It is an emotional index for studying investors' psychological fluctuations in response to market ups and downs, and it's a type of energy and rise-fall indicator. It has certain reference significance for judging short-term market trends.

The PSY factor was first proposed by Dr. Wang Yawei in 1991. He believed that the psychological changes in the market are closely related to price trends, and quantified these psychological changes into the PSY factor. As an indicator for analyzing market fluctuations, the PSY factor calculates the total bullish and bearish forces within N K-lines over time to describe whether the current market is strong or weak, or if it's in an overbought or oversold state. It mainly measures investors' psychological endurance by calculating how many rising K-lines there are within N K-lines, providing a reference for investors' buying and selling operations.

The PSY factor is based on the number of days the closing price rises or falls over a period of time. Its calculation method is very simple, and the calculation formula is as follows: PSY=(Number of rising days within N K-lines/N)*100. Here, N period represents the selected calculation period, which can be several days, weeks or months etc. The number of rising days refers to the number of trading days with rising prices within the N period. The initial PSY factor function source code based on FMZ platform:

```
function calculatePSY(data, n) {
let count = 0;
for (let i = data.length - n; i < data.length; i++) {
if (data[i] > data[i - 1]) {
count++;
}
}
return (count / n) * 100;
}

// Usage example
let closePrices = [10, 12, 13, 11, 14, 15, 16, 17, 18, 20];
let nPeriod = 5;
let psyFactor = calculatePSY(closePrices, nPeriod);
Log(psyFactor);
```
> PART2 Enhance PSY Factor (PSY+PRICE)

The essence of the PSY factor is a momentum factor, which measures the comparison of the root numbers of rising and falling forces over a period of time, with the aim to find out which side has greater strength in the past. However, upon careful observation, it can be found that the PSY factor only considers whether the BAR line is rising or falling, lacking a description of BAR itself and unable to judge the intensity of market conditions, resulting in situations -- Of the last 6 K-lines, 3 were down and 3 were up, and the value of 50, as constructed by the initial PSY factor, it does not discern the strength of the long and short forces in the last 6 K-lines.

As mentioned above, the uniqueness of a large bullish K-line is not reflected in the PSY indicator, it's merely treated as an upward line with no difference from the previous small bearish K-line. This is where the problem lies, as the number of rises and falls cannot fully describe the magnitude and direction of price changes. Therefore, our first improvement idea was to weight each BAR's price change Abs(C-C[1]) to reflect the magnitude of rise and fall forces. The source code for initial PSY+PRICE factor function based on FMZ platform:
https://stocksharp.com/file/149482
> PART3 Final PSY Factor (PSY+PRICE+VOL)

After the modification in the previous step, the transformed PSY factor can better reflect the strength and weakness over a period of time. However, it cannot distinguish well if the rise and fall range is basically consistent during that period. At this point, we continue to add trading volume factors. In momentum effect, increased volume represents a more active market, and increased volume situation can better confirm momentum direction. As shown in the figure below:
https://stocksharp.com/file/149483
Over the past period of time, the magnitude of the rise and the fall were basically the same, but the volume in the rise far exceeded the volume in the fall, reflecting the superior upward force. Therefore, in the final PSY factor, we continue to add the volume factor weighting, VOLUME*Abs(C-C[1]), based on the initial PSY+PRICE factor function source code of FMZ platform:
https://stocksharp.com/file/149487
> PART4 Construction of PSY Factor Trading Signals

Based on the final PSY+PRICE+VOL factor constructed in the previous article, we attempt to propose several constructions of momentum signals as follows:

- psy[0] > X (Over a period of time in the past, the ratio of multiple forces was greater than X value.)
- psy[0] < Y (Over a period of time in the past, the ratio of multiple forces was less than Y value.)
- psy[0] > psy[1] or psy[0] > psyma (Over the past period of time, the ratio of various forces has increased.)
- psy[0] < psy[1] or psy[0] < psyma (Over a period of time, the ratio of multiple forces has decreased.)

We design a simple momentum strategy with signals to detect factors.

- Go long: PSY[0] > 70; Close long position: PSY[0] < 30;
- Go short: PSY[0] < 30; Close short position: PSY[0] > 70;

Using Binance U-denominated contracts, the PSY factor parameter is designed to be 12. Backtesting of BTC-USDT and ETH-USDT contracts was conducted from February 1, 2020 to December 31, 2021 with a slippage of 10, a transaction fee of 0.05%, a leverage of 10 times, and each position remaining principal at 5%:

BTC-USDT：
https://stocksharp.com/file/149484
ETH-USDT：
https://stocksharp.com/file/149485
> PART5 Summary

In this article, we upgraded and transformed the traditional psy factor, resulting in a psy+price+vol factor that can measure the strength of bulls and bears over a past period at the level of volume and price. Using fixed numerical comparisons or self-strength comparisons, corresponding momentum/reversal signals can be constructed. This article finally established a fixed numerical signal, conducted simple strategy backtesting, and found that the psy+price+vol factor can capture momentum movements in volatile markets to some extent, achieving positive expected returns. More forms of signals can be constructed later for more types of factor tests before ultimately being added to an existing strategy library.

Thanks to the FMZ Platform, for not closing its doors and reinventing the wheel, but providing such a great place for traders to communicate. The road of trading is full of ups and downs, but with warmth from fellow traders and continuous learning from the shared experiences of seniors on the FMZ platform, we can keep growing. Wishing FMZ all the best and may all traders enjoy long-lasting profits.

From: https://blog.mathquant.c...-and-transformation.html

Unveiling Market Noise: Building and Applying Strategies for a Clearer Trading Path

2024-03-21T07:34:26Z

Welcome all traders to my channel, I am a Quant Developer, specializing in full-stack development of CTA, HFT & Arbitrage trading strategies.
Thanks to the FMZ Platform, I will share more content related to quantitative development and work together with all traders to maintain the prosperity of the quant community.

- Do you often struggle to distinguish between trends and fluctuations?
- Have you been stopped out by the back-and-forth disorderly market?
- Are you having difficulty understanding the current market situation?
- Do you do trend trading and hope to filter out fluctuations?

Haha, you've come to the right place. Today, I will bring you the construction and application of market noise! As we all know, financial markets are full of noise. How to quantitatively model and depict market noise is very important. The depiction of noise can better help us distinguish the current state of the market and predict future possibilities!

> PART1 Noise discrimination is very important for financial market trading.

The time series in the financial market is characterized by a high signal-to-noise ratio, most of the time, the market fluctuations are unclear, and even during trending markets, situations like taking four steps forward and three steps back often occur. Therefore, defining, identifying and classifying market noise in the financial market is very important and has practical significance. Kaufman's book provides a comprehensive explanation and modeling of this characteristic of noise.
https://stocksharp.com/file/149465
> PART2 Construction of Noise - ER Efficiency Coefficient
https://stocksharp.com/file/149463
The net value of the starting and ending points of price changes divided by the sum of all pairwise price changes during the period.
https://stocksharp.com/file/149456
The difference between point A and point B divided by the sum of the 7 intermediate movements.
https://stocksharp.com/file/149457
It demonstrates the different noise levels exhibited by various price operation modes under the same price movement range. A straight line indicates no noise, minor fluctuations around the straight line represent medium noise, and large swings symbolize high noise.

> PART3 Construction of Noise - Price Density
https://stocksharp.com/file/149464
The definition here is: Drawing the high and low points of price movements over a period of time, pulling the highest and lowest prices during this period into a box. The so-called price density refers to the number of price points that can be accommodated within the box.
https://stocksharp.com/file/149458
https://stocksharp.com/file/149459
Compared to the ER efficiency coefficient, the measurement method of price density takes more into account the highest and lowest prices of each K-line.

> PART4 Construction of Noise - Fractal Dimension

The fractal dimension cannot be measured accurately, but it can be estimated using the following steps within the past n terms:
https://stocksharp.com/file/149460
> PART5 Construction of Noise - Other Methods

CMI = (close[0] - open[n-1]) / (Max high(n) - Min low(n));
When the noise is lower, during this period, the net value at the beginning and end infinitely approaches the difference between the highest and lowest prices, with CMI infinitely approaching 1.
https://stocksharp.com/file/149461
https://stocksharp.com/file/149476
The results obtained from the construction methods of various noise measurements are highly similar. The core is to compare the net changes and change processes or extreme values of a period of movement, and choose the construction method that you prefer or think is more reasonable.

> PART6 Dividing market styles from the perspectives of noise and volatility.
https://stocksharp.com/file/149462
Volatility and noise are different dimensions to characterize the market. The sum of price changes in the two types of price models mentioned above is the same, so their volatility is the same, but net value changes more significantly and noise is lower.

Therefore, noise and volatility are two different perspectives that can be used to classify market styles. If we take persistence and volatility of trends as the x-axis and y-axis respectively to construct a Cartesian coordinate system, we can divide the fluctuation status of market prices into four categories:
https://stocksharp.com/file/149471
- Good sustainability, high volatility - smooth trend.
https://stocksharp.com/file/149467
- Good sustainability, low volatility - bumpy trend.
https://stocksharp.com/file/149472
- Persistent poor performance, low volatility - narrow range consolidation.
https://stocksharp.com/file/149466
- Persistent poor performance, high volatility - wide range fluctuations.
https://stocksharp.com/file/149473
It should be pointed out that there are no absolute standards for what is called wide range and narrow range, it has to be relative to the level and system of one's own trading, just like the setting of the trading period, which is extremely personalized. Moreover, we can only determine the current state of the market by examining a period in the past. However, we cannot predict what state the market will enter next.

Of course, the four types of fluctuations are not completely random during conversion. In the most ideal state, a smooth trend is often followed by wide-range oscillations, slowly unloading momentum; then it enters narrow-range consolidation, the market is very inactive, and bulls and bears are stuck in a stalemate; when the market is compressed to a critical point, it explodes again and the trend begins; this is an oversimplified ideal model - reality is much more complex. For example, after narrow-range consolidation there may not necessarily be a trend - it could also be wide-ranging oscillation. After a smooth trend there might not necessarily be wide-ranging oscillation - it could continue to reach new highs or lows. Moreover, it's difficult to develop four strategies that excel at handling four different market conditions and can adapt as needed. So for now, I still think we can only develop strategies that make money in certain markets while minimizing losses in unfavorable ones.

> PART7 Impact of Noise on Related Transactions
https://stocksharp.com/file/149477
The profit factor of the 40-day moving average strategy (going long above the 40-day line and short below, total profit/total loss) is regressed with the 40-day noise (ER efficiency coefficient). It can be seen that the higher the noise, the lower the profit factor of trend strategies. And we can conclude: low noise is beneficial for trend trading, high noise is beneficial for mean reversion trading.
https://stocksharp.com/file/149478
The concept of market noise is very important in determining trading styles. Before developing corresponding trading strategies, we need to outline the contours of the market.
https://stocksharp.com/file/149469
> PART8 Market Maturity and Noise

Over the past 20 years, the noise attribute of the North American stock index market has experienced a steady rise.
https://stocksharp.com/file/149468
Financial markets in various regions are gradually maturing, with noise levels increasing progressively, and the maturity is coming quickly.
https://stocksharp.com/file/149470
A study was conducted on the stock index markets of various countries. The market on the far right is the most mature and also has higher noise, while the one on the far left is immature with lower noise. It can be observed that Japan has the most mature market, followed by economies like Hong Kong, China, Singapore, and South Korea. On the far left are relatively immature markets, such as Vietnam and Sri Lanka.
https://stocksharp.com/file/149474
The noise in the Bitcoin market for each quarter is approximately 0.2-0.3, and it's in a cyclical state.
https://stocksharp.com/file/149475
Thanks to the FMZ Platform, for not closing its doors and reinventing the wheel, but providing such a great place for traders to communicate. The road of trading is full of ups and downs, but with warmth from fellow traders and continuous learning from the shared experiences of seniors on the FMZ platform, we can keep growing. Wishing FMZ all the best and may all traders enjoy long-lasting profits.

From: https://blog.mathquant.c...ion-of-market-noise.html

Mastering Programmatic Trading: The Game-Changing Incremental Update Algorithm for Mean and Variance Calculation

2024-03-21T05:44:08Z

### Introduction
In programmatic trading, it is often necessary to calculate averages and variances, such as calculating moving averages and volatility indicators. When we need high-frequency and long-term calculations, it's necessary to retain historical data for a long time, which is both unnecessary and resource-consuming. This article introduces an online updating algorithm for calculating weighted averages and variances, which is particularly important for processing real-time data streams and dynamically adjusting trading strategies, especially high-frequency strategies. The article also provides corresponding Python code implementation to help traders quickly deploy and apply the algorithm in actual trading.

### Simple Average and Variance
If we use https://stocksharp.com/file/149441 to represent the average value of the nth data point, assuming that we have already calculated the average of n-1 data points https://stocksharp.com/file/149454, now we receive a new data point https://stocksharp.com/file/149442. We want to calculate the new average number https://stocksharp.com/file/149441 including the new data point. The following is a detailed derivation.
https://stocksharp.com/file/149450
The variance update process can be broken down into the following steps:
https://stocksharp.com/file/149455
As can be seen from the above two formulas, this process allows us to update new averages and variances upon receiving each new data point https://stocksharp.com/file/149442 by only retaining the average and variance of the previous data, without saving historical data, making calculations more efficient. However, the problem is that what we calculate in this way are the mean and variance of all samples, while in actual strategies, we need to consider a certain fixed period. Observing the above average update shows that the amount of new average updates is a deviation between new data and past averages multiplied by a ratio. If this ratio is fixed, it will lead to an exponentially weighted average, which we will discuss next.

### Exponentially-weighted mean
The exponential weighted average can be defined by the following recursive relationship:
https://stocksharp.com/file/149445
Among them, https://stocksharp.com/file/149451 is the exponential weighted average at time point t, https://stocksharp.com/file/149444 is the observed value at time point t, α is the weight factor, and https://stocksharp.com/file/149447 is the exponential weighted average of the previous time point.

### Exponentially-weighted variance
Regarding variance, we need to calculate the exponential weighted average of squared deviations at each time point. This can be achieved through the following recursive relationship:
https://stocksharp.com/file/149452
Among them, https://stocksharp.com/file/149453 is the exponential weighted variance at time point t, and https://stocksharp.com/file/149449 is the exponential weighted variance of the previous time point.

Observe the exponentially weighted average and variance, their incremental updates are intuitive, retaining a portion of past values and adding new changes. The specific derivation process can be referred to in this paper: https://fanf2.user.srcf....c/antiforgery/stats.pdf

### SMA and EMA
The SMA (also known as the arithmetic mean) and EMA are two common statistical measures, each with different characteristics and uses. The former one assigns equal weight to each observation, reflecting the central position of the data set. The latter one is a recursive calculation method that gives higher weight to more recent observations. The weights decrease exponentially as the distance from current time increases for each observation.

- **Weight distribution**: The SMA assigns the same weight to each data point, while the EMA gives higher weight to the most recent data points.
- **Sensitivity to new information**: The SMA is not sensitive enough to newly added data, as it involves recalculating all data points. The EMA, on the other hand, can reflect changes in the latest data more quickly.
- **Computational complexity**: The calculation of the SMA is relatively straightforward, but as the number of data points increases, so does the computational cost. The computation of the EMA is more complex, but due to its recursive nature, it can handle continuous data streams more efficiently.

### Approximate Conversion Method Between EMA and SMA
Although SMA and EMA are conceptually different, we can make the EMA approximate to a SMA containing a specific number of observations by choosing an appropriate α value. This approximate relationship can be described by the effective sample size, which is a function of the weight factor α in the EMA.

SMA is the arithmetic average of all prices within a given time window. For a time window N, the centroid of the SMA (i.e., the position where the average number is located) can be considered as:

the centroid of SMA https://stocksharp.com/file/149443

EMA is a type of weighted average where the most recent data points have greater weight. The weight of EMA decreases exponentially over time. The centroid of EMA can be obtained by summing up the following series:

the centroid of EMA https://stocksharp.com/file/149438

When we assume that SMA and EMA have the same centroid, we can obtain:
https://stocksharp.com/file/149448
To solve this equation, we can obtain the relationship between α and N.
https://stocksharp.com/file/149446
This means that for a given SMA of N days, the corresponding α value can be used to calculate an "equivalent" EMA, so that they have the same centroid and the results are very similar.

### Conversion of EMA with Different Update Frequencies
Assume we have an EMA that updates every second, with a weight factor of https://stocksharp.com/file/149437. This means that every second, the new data point will be added to the EMA with a weight of https://stocksharp.com/file/149434, while the influence of old data points will be multiplied by https://stocksharp.com/file/149437.

If we change the update frequency, such as updating once every f seconds, we want to find a new weight factor https://stocksharp.com/file/149440, so that the overall impact of data points within f seconds is the same as when updated every second.

Within f seconds, if no updates are made, the impact of old data points will continuously decay f times, each time multiplied by /upload/asset/28e50eb9c37d5626d6691.png. Therefore, the total decay factor after f seconds is https://stocksharp.com/file/149436.

In order to make the EMA updated every f seconds have the same decay effect as the EMA updated every second within one update period, we set the total decay factor after f seconds equal to the decay factor within one update period:
https://stocksharp.com/file/149439
Solving this equation, we obtain new weight factors https://stocksharp.com/file/149440
https://stocksharp.com/file/149435
This formula provides the approximate value of the new weight factor https://stocksharp.com/file/149440, which maintains the EMA smoothing effect unchanged when the update frequency changes. For example: When we calculate the average price https://stocksharp.com/file/149437 with a value of 0.001 and update it every 10 seconds, if it is changed to an update every second, the equivalent value https://stocksharp.com/file/149440 would be approximately 0.01.

### Implementation of Python Code
```
class ExponentialWeightedStats:
def __init__(self, alpha):
self.alpha = alpha
self.mu = 0
self.S = 0
self.initialized = False

def update(self, x):
if not self.initialized:
self.mu = x
self.S = 0
self.initialized = True
else:
temp = x - self.mu
new_mu = self.mu + self.alpha * temp
self.S = self.alpha * self.S + (1 - self.alpha) * temp * (x - self.mu)
self.mu = new_mu

@property
def mean(self):
return self.mu

@property
def variance(self):
return self.S

# Usage example
alpha = 0.05 # Weight factor
stats = ExponentialWeightedStats(alpha)
data_stream = [] # Data stream
for data_point in data_stream:
stats.update(data_point)
```
### Summary
In high-frequency programmatic trading, the rapid processing of real-time data is crucial. To improve computational efficiency and reduce resource consumption, this article introduces an online update algorithm for continuously calculating the weighted average and variance of a data stream. Real-time incremental updates can also be used for various statistical data and indicator calculations, such as the correlation between two asset prices, linear fitting, etc., with great potential. Incremental updating treats data as a signal system, which is an evolution in thinking compared to fixed-period calculations. If your strategy still includes parts that calculate using historical data, consider transforming it according to this approach: only record estimates of system status and update the system status when new data arrives; repeat this cycle going forward.

From: https://blog.mathquant.c...g-mean-and-variance.html

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