@steerprotocol/strategy-utils 2.1.9 → 2.2.1

package/assembly/utils/CandleGenerator.ts

@@ -0,0 +1,60 @@
+import { Candle } from "./types/Candle";
+import { RawTradeData } from "./types/RawTradeData";
+
+// CandlestickConverter class provides a static method to convert raw trade data into OHLCV format
+export class CandlestickConverter {
+    // convertToOHLCV method accepts raw trade data and a period (default is 3600 seconds or 1 hour)
+    // and returns the data in OHLCV format
+    static convertToOHLCV(rawData: RawTradeData[], period: i32 = 3600): Candle[] {
+        // If the raw data is empty, an error is thrown
+        if (rawData.length === 0) {
+            throw new Error("Input data is empty");
+        }
+
+        // Array to hold the converted data
+        let ohlcvData: Candle[] = [];
+
+        // Initialize variables
+        let i: i32 = 0;
+        let currentTimestamp: i32 = Math.floor(rawData[0].timestamp / period) * period;
+        let open: f64 = rawData[0].price;
+        let high: f64 = rawData[0].price;
+        let low: f64 = rawData[0].price;
+        let close: f64 = rawData[0].price;
+        let volume: f64 = 0.0;
+
+        // Loop through all raw data
+        while (i < rawData.length) {
+            // For each period, set the initial values of open, high, low to the closing price of the last period
+            // and reset the volume to 0
+            open = close;
+            high = close;
+            low = close;
+            volume = 0.0;
+
+            // Process all raw data within the current period
+            while (i < rawData.length && rawData[i].timestamp < currentTimestamp + period) {
+                // Set the open price to the price of the first trade in the period
+                open = i == 0 ? rawData[i].price : open;
+                // Update high and low prices
+                high = Math.max(high, rawData[i].price);
+                low = Math.min(low, rawData[i].price);
+                // Update close price to the price of the last trade in the period
+                close = rawData[i].price;
+                // Update the total volume
+                volume += rawData[i].volume;
+                i++;
+            }
+
+            // Create a new Candle object with the calculated OHLCV values and add it to the array
+            let ohlcv: Candle = new Candle(currentTimestamp, open, high, low, close, volume);
+            ohlcvData.push(ohlcv);
+
+            // Move to the next period
+            currentTimestamp += period;
+        }
+
+        // Return the converted data
+        return ohlcvData;
+    }
+}

package/assembly/utils/Math.ts

@@ -1,4 +1,4 @@
-export function _getMax(arr: Array<f32>): f32 {
+export function _getMax(arr: Array<f64>): f64 {
     let max = arr[0];
     for (let i = 1; i < arr.length; i++) {
       if (arr[i] > max) {
@@ -8,36 +8,41 @@ export function _getMax(arr: Array<f32>): f32 {
     return max;
   }
 
-  export function getMax(a: f32, b: f32): f32 {
+  export function getMax(a: f64, b: f64): f64 {
     if (a >= b) return a
     return b
 }
 
 
-export function _normalDensity(std: f32, mean: f32, x: f32): f32 {
-  return f32(
-    (f32(Math.E) ** (((x - mean) / std) ** 2 / -2) / std) *
-      Math.sqrt(2 * f32(Math.PI))
+export function _normalDensity(std: f64, mean: f64, x: f64): f64 {
+  return f64(
+    (f64(Math.E) ** (((x - mean) / std) ** 2 / -2) / std) *
+      Math.sqrt(2 * f64(Math.PI))
   );
 }
 
-export function _standardDeviation(list:f32[]): f32 {
+export function _standardDeviation(list:f64[]): f64 {
   const mean = _mean(list)
-  const sqrdDiff: f32[] = []
+  const sqrdDiff: f64[] = []
   for (let i = 0; i < list.length; i++){
       sqrdDiff.push((list[i]-mean)*(list[i]-mean))
   }
   const variance = _mean(sqrdDiff)
   const stddev = Math.sqrt(variance)
-  return f32(stddev)
+  return f64(stddev)
 }
 
 // SMA simple moving average
-export function _mean(list: f32[]): f32 {
+export function _mean(list: f64[]): f64 {
   const length = list.length;
-  let total: f32 = 0.0;
+  let total: f64 = 0.0;
   for (let i = 0; i < length; i++){
       total += list[i]
   }
-  return total / f32(length)
+  return total / f64(length)
+}
+
+export function closestDivisibleNumber(num: number, divisor: number, floor: boolean): number {
+  if (floor) return Math.floor(num / divisor) * divisor;
+  return Math.ceil(num / divisor) * divisor;
 }

package/assembly/utils/MovingAverages.ts

@@ -1,18 +1,18 @@
 export class SMA {
-  private readonly prices: f32[] = [];
+  private readonly prices: f64[] = [];
   private interval: i32 = 0;
-  private result: f32;
-  private prevEMA: f32;
+  private result: f64 = 0
+  // private prevEMA: f64;
 
   constructor(interval: i32) {
     this.interval = interval;
   }
 
-  getResult(): f32 {
+  getResult(): f64 {
     return this.result;
   }
 
-  update(price: f32): void {
+  update(price: f64): void {
     this.prices.push(price);
 
     if (this.prices.length > this.interval) {
@@ -20,32 +20,32 @@ export class SMA {
     }
 
     if (this.prices.length === this.interval) {
-      let result = f32(0);
+      let result = f64(0);
       for (let priceIndex = 0; priceIndex < this.prices.length; priceIndex++) {
         result = result + this.prices[priceIndex];
       }
-      this.result = result / f32(this.prices.length || 1);
+      this.result = result / f64(this.prices.length || 1);
     }
   }
 }
 
 export class EMA {
-  private readonly prices: f32[] = [];
+  private readonly prices: f64[] = [];
   private interval: i32 = 0;
-  private result: f32;
+  private result: f64 = 0
   private multiplier: i32;
-  private prevEMA: f32;
+  private prevEMA: f64 = 0
 
   constructor(interval: i32, multiplier: i32) {
     this.interval = interval;
     this.multiplier = multiplier;
   }
 
-  getResult(): f32 {
+  getResult(): f64 {
     return this.result;
   }
 
-  update(price: f32): void {
+  update(price: f64): void {
     this.prices.push(price);
 
     if (this.prices.length > this.interval) {
@@ -56,11 +56,11 @@ export class EMA {
       this.prevEMA = price;
     }
 
-    let p1 = price * (f32(this.multiplier) / (1 + f32(this.interval)));
+    let p1 = price * (f64(this.multiplier) / (1 + f64(this.interval)));
     let p2 =
-      this.prevEMA * (1 - f32(this.multiplier) / (1 + f32(this.interval)));
+      this.prevEMA * (1 - f64(this.multiplier) / (1 + f64(this.interval)));
 
-    this.result = f32(p1 + p2);
+    this.result = f64(p1 + p2);
     this.prevEMA = this.result;
   }
 }

package/assembly/utils/Ranges.ts

@@ -1,8 +1,8 @@
 import { Candle } from "./types/Candle";
 import { getMax, _mean, _getMax } from "./Math";
 
-export function getAverageTrueRange(candles: Array<Candle>, interval: i32): f32 {
-    let rangeSum: f32 = 0;
+export function getAverageTrueRange(candles: Array<Candle>, interval: i32): f64 {
+    let rangeSum: f64 = 0;
     for (let i = 1; i < candles.length; i++) {
       const currentPrice = candles[i];
 
@@ -14,34 +14,34 @@ export function getAverageTrueRange(candles: Array<Candle>, interval: i32): f32
       const range2 = Math.abs(currentLow - previousClose);
       const range3 = Math.abs(currentHigh - currentLow);
   
-      let max = _getMax([f32(range1), f32(range2), f32(range3)]);
+      let max = _getMax([f64(range1), f64(range2), f64(range3)]);
       rangeSum += max;
     }
     
 
-    return f32(rangeSum) / f32(candles.length - 1);
+    return f64(rangeSum) / f64(candles.length - 1);
 
   }
 
 
-  export   function trailingStop(percent: f32, prices: Candle[]): f32 {
+  export   function trailingStop(percent: f64, prices: Candle[]): f64 {
     // Get the current price of the asset pair
     const currentPrice = prices[prices.length - 1];
 
     // Calculate the trailing stop price
-    const trailingStopPrice = currentPrice.close - (currentPrice.close * f32(percent / 100));
+    const trailingStopPrice = currentPrice.close - (currentPrice.close * f64(percent / 100));
 
     // Return the trailing stop price
-    return f32(trailingStopPrice);
+    return f64(trailingStopPrice);
 }
 
-export function trueRange(price: Candle): f32{
-  const trueRange = getMax(f32(price.high) - f32(price.low),getMax(f32(Math.abs(price.high-price.close)),f32(Math.abs(price.low-price.close))));
+export function trueRange(price: Candle): f64{
+  const trueRange = getMax(f64(price.high) - f64(price.low),getMax(f64(Math.abs(price.high-price.close)),f64(Math.abs(price.low-price.close))));
   return trueRange;
 }
 
-export function averageTrueRange(prices: Candle[]): f32 {
-  const trueRanges: f32[] = []
+export function averageTrueRange(prices: Candle[]): f64 {
+  const trueRanges: f64[] = []
   for (let i = 0; i < prices.length; i++) {
       trueRanges.push(trueRange(prices[i]));
   }

package/assembly/utils/env.ts

@@ -1 +1,2 @@
-export declare function generateCandles(data: string, candleSize: string): string
+export declare function generateCandles(data: string, candleSize: string): string
+export declare function ccxt_fetchOHLCV(exchangeId: string, symbol: string, timeframe: string, limit: number, since: number): string

package/assembly/utils/types/Candle.ts

@@ -3,13 +3,13 @@ import { JSON } from 'json-as/assembly';
 @serializable
 export class Candle {
   timestamp: i64 = 0; 
-  high: number = 0.0; 
-  low: number  = 0.0;
-  open: number = 0.0;
-  close: number = 0.0;
-  volume: number = 0.0;
+  high: f64 = 0.0; 
+  low: f64  = 0.0;
+  open: f64 = 0.0;
+  close: f64 = 0.0;
+  volume: f64 = 0.0;
 
-  constructor(timestamp: i64, high: number, low: number, open: number, close: number, volume: number) {
+  constructor(timestamp: i64, high: f64, low: f64, open: f64, close: f64, volume: f64) {
     this.timestamp = timestamp;
     this.high = high;
     this.low = low;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerprotocol/strategy-utils",
-  "version": "2.1.9",
+  "version": "2.2.1",
   "description": "Strategy utilities library for Steer Protocol strategies",
   "main": "assembly/index.ts",
   "types": "assembly/index.ts",