@steerprotocol/strategy-utils 2.2.0 → 3.0.0

package/.github/workflows/nodejs.yml

@@ -25,14 +25,14 @@ jobs:
         if: steps.node-cache.outputs.cache-hit != 'true'
         run: yarn
 
-      - name: Test to see if the project compiles
-        run: yarn asbuild
+      # - name: Test to see if the project compiles
+      #   run: yarn asbuild
 
       - name: Perform tests
         run: yarn test
 
-      - name: Create the docs directory locally in CI
-        run: yarn docs
+      # - name: Create the docs directory locally in CI
+      #   run: yarn docs
 
       - name: Release
         run: npx semantic-release
@@ -40,8 +40,8 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.SEMANTIC_RELEASE_BOT_NPM_TOKEN }}
 
-      - name: Deploy 🚀
-        uses: JamesIves/github-pages-deploy-action@4.1.4
-        with:
-          branch: gh-pages
-          folder: docs
+      # - name: Deploy 🚀
+      #   uses: JamesIves/github-pages-deploy-action@4.1.4
+      #   with:
+      #     branch: gh-pages
+      #     folder: docs

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+## [1.2.0-alpha.2](https://github.com/SteerProtocol/strategy-utils-assemblyscript/compare/v1.2.0-alpha.1...v1.2.0-alpha.2) (2023-08-17)
+
+
+### Features
+
+* :sparkles: Trigger Logic Utils ([dc1058c](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/dc1058c48db7b7f1ae6ad9de321a49023859cd1e))
+* :zap: Latest spec for bundle interfacing ([c7287a5](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/c7287a5ef5510d67b9ec884d3529fc1bda14ac3d))
+* :zap: Trigger logic and tests ([5105832](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/510583295e2f9b94d0091ff9944daf6c84eb9196))
+
+
+### Bug Fixes
+
+* :white_check_mark: Fix tests ([2944e90](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/2944e90dbf4e532c934dcef325ff023e863fcef7))
+
+## [1.2.0-alpha.1](https://github.com/SteerProtocol/strategy-utils-assemblyscript/compare/v1.1.2-alpha.1...v1.2.0-alpha.1) (2023-08-15)
+
+
+### Features
+
+* :zap: f32 -> f64 conversion ([19c98cb](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/19c98cb82dab0057cec790de29188c20bab09f76))
+* asyncify support ([45234ab](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/45234ab5edfc389580f09392e9b5c47ff2cbc1dc))
+* Integrate ccxt into strategy-utils ([bbc67b5](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/bbc67b52462163581e020b7576cc5b176102952b))
+
+
+### Bug Fixes
+
+* array GC issues ([15a3a36](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/15a3a36b2779ac64341867ac4d8eabe6748bd55d))
+
 ### [1.1.2-alpha.1](https://github.com/SteerProtocol/strategy-utils-assemblyscript/compare/v1.1.1...v1.1.2-alpha.1) (2022-08-15)
 
 

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/MarketFeedAggregator.ts

@@ -0,0 +1,140 @@
+class Candle {
+    timestamp: f64;
+    open: f64;
+    high: f64;
+    close: f64;
+    low: f64;
+    volume: f64;
+
+    constructor(
+        timestamp: f64,
+        open: f64,
+        high: f64,
+        close: f64,
+        low: f64,
+        volume: f64
+    ) {
+        this.timestamp = timestamp;
+        this.open = open;
+        this.high = high;
+        this.close = close;
+        this.low = low;
+        this.volume = volume;
+    }
+}
+
+class MarketFeedAggregator {
+    data: Array<Candle>;
+
+    constructor(data: Array<Candle>) {
+        this.data = data;
+    }
+
+    geometricMean(): Candle {
+        let n: f64 = f64(this.data.length);
+        let logSum = new Candle(0, 0, 0, 0, 0, 0);
+
+        for (let i = 0; i < this.data.length; i++) {
+            let candle = this.data[i];
+            logSum.timestamp += Mathf.log(candle.timestamp);
+            logSum.open += Mathf.log(candle.open);
+            logSum.high += Mathf.log(candle.high);
+            logSum.close += Mathf.log(candle.close);
+            logSum.low += Mathf.log(candle.low);
+            logSum.volume += Mathf.log(candle.volume);
+        }
+
+        return new Candle(
+            Mathf.exp(logSum.timestamp / n),
+            Mathf.exp(logSum.open / n),
+            Mathf.exp(logSum.high / n),
+            Mathf.exp(logSum.close / n),
+            Mathf.exp(logSum.low / n),
+            Mathf.exp(logSum.volume / n)
+        );
+    }
+
+    timeWeightedAveragePrice(): f64 {
+        let sumProduct: f64 = 0;
+        let sumTime: f64 = 0;
+
+        for (let i = 0; i < this.data.length; i++) {
+            let candle = this.data[i];
+            let midPrice: f64 = (candle.high + candle.low) / 2;
+            sumProduct += midPrice * candle.timestamp;
+            sumTime += candle.timestamp;
+        }
+
+        return sumProduct / sumTime;
+    }
+
+    volumeWeightedAveragePrice(): f64 {
+        let sumProduct: f64 = 0;
+        let sumVolume: f64 = 0;
+
+        for (let i = 0; i < this.data.length; i++) {
+            let candle = this.data[i];
+            let midPrice: f64 = (candle.high + candle.low) / 2;
+            sumProduct += midPrice * candle.volume;
+            sumVolume += candle.volume;
+        }
+
+        return sumProduct / sumVolume;
+    }
+
+    weightedMean(weights: Candle): Candle {
+        let sumWeights: f64 = 0;
+        let sumProduct: Candle = new Candle(0, 0, 0, 0, 0, 0);
+
+        for (let i = 0; i < this.data.length; i++) {
+            let candle = this.data[i];
+            sumProduct.timestamp += weights.timestamp * candle.timestamp;
+            sumProduct.open += weights.open * candle.open;
+            sumProduct.high += weights.high * candle.high;
+            sumProduct.close += weights.close * candle.close;
+            sumProduct.low += weights.low * candle.low;
+            sumProduct.volume += weights.volume * candle.volume;
+
+            sumWeights +=
+                weights.timestamp +
+                weights.open +
+                weights.high +
+                weights.close +
+                weights.low +
+                weights.volume;
+        }
+
+        return new Candle(
+            sumProduct.timestamp / sumWeights,
+            sumProduct.open / sumWeights,
+            sumProduct.high / sumWeights,
+            sumProduct.close / sumWeights,
+            sumProduct.low / sumWeights,
+            sumProduct.volume / sumWeights
+        );
+    }
+
+    arithmeticMean(): Candle {
+        let n: f64 = f64(this.data.length);
+        let sum: Candle = new Candle(0, 0, 0, 0, 0, 0);
+
+        for (let i = 0; i < this.data.length; i++) {
+            let candle = this.data[i];
+            sum.timestamp += candle.timestamp;
+            sum.open += candle.open;
+            sum.high += candle.high;
+            sum.close += candle.close;
+            sum.low += candle.low;
+            sum.volume += candle.volume;
+        }
+
+        return new Candle(
+            sum.timestamp / n,
+            sum.open / n,
+            sum.high / n,
+            sum.close / n,
+            sum.low / n,
+            sum.volume / n
+        );
+    }
+}

package/assembly/utils/Ranges.ts

@@ -1,7 +1,7 @@
 import { Candle } from "./types/Candle";
 import { getMax, _mean, _getMax } from "./Math";
 
-export function getAverageTrueRange(candles: Array<Candle>, interval: i32): f64 {
+export function getAverageTrueRange(candles: Array<Candle>): f64 {
     let rangeSum: f64 = 0;
     for (let i = 1; i < candles.length; i++) {
       const currentPrice = candles[i];

package/assembly/utils/env.ts

@@ -1 +1,23 @@
-export declare function generateCandles(data: string, candleSize: string): string
+export declare function generateCandles(data: string, candleSize: string): string;
+@external("env", "ccxt_fetchOHLCV")
+declare function _ccxt_fetchOHLCV(exchangeId: string, symbol: string, timeframe: string, limit: number, since: number): StaticArray<StaticArray<f64>>;
+
+// Required for asyncify
+// @ts-ignore: Global should exist here
+@global let __ASYNCIFY_INITIALIZED = false;
+@external("env", "_initAsyncify")
+declare function _initAsyncify(asyncify_data_ptr: usize, stack_pointer: usize): void;
+
+export function ccxt_fetchOHLCV(exchangeId: string, symbol: string, timeframe: string, limit: number, since: number): StaticArray<StaticArray<f64>> {
+    if (!__ASYNCIFY_INITIALIZED) {
+        // We need to initialize space for Asyncify to work.
+        // Asyncify will create a full - duplex communication channel through this bit of memory.
+        // For every asyncify-enabled function, make sure to add this
+        // memory.data() reserves a section of data that is not touched by the Garbage Collector
+        // We can only do this once or else we will cause a memory leak and eventual overflow
+        // It will not grow past the stack pointer which is where real data starts.
+        _initAsyncify(memory.data(8, 16), __stack_pointer);
+        __ASYNCIFY_INITIALIZED = true;
+    }
+    return _ccxt_fetchOHLCV(exchangeId, symbol, timeframe, limit, since);
+}