@steerprotocol/strategy-utils 3.1.2 → 3.2.0

package/tests/index.test.ts

@@ -1,238 +1,66 @@
-import {  candles2,  } from "./utils";
-import fs from 'fs';
-import { WasmModule, loadWasm } from "@steerprotocol/app-loader";
+const fs = require('fs');
+const os = require('os');
+const { execFileSync } = require('child_process');
+const loader = require('@assemblyscript/loader');
+const path = require('path');
 
-
-describe("Unit tests", () => {
-  let myModule: WasmModule;
-  
-  beforeEach(async () => {
-    myModule = await loadWasm(fs.readFileSync(__dirname + "/debug.wasm"), {})
-  });
-
-    describe("Trigger tests", () => {
-      // Testing the following options
-      // 'Current Price set distance from center of positions',
-      // 'Price leaves active range',
-      // 'Price moves percentage of active range away',
-      // 'Price moves one way past positions',
-      // 'None'
-// TEST tirggers
-test("Can return positions on none type", async () => {        
-  const config = `{
-    "triggerStyle": "None",
-    "period":6,
-    "standardDeviations":2.0,
-    "liquidityShape": "Linear",
-    "poolFee": 3000,
-    "placementType": "Position over current price",
-    "positionSize": 600
-  }`
-  myModule.initialize(config);
-  const positions = '[[257100],[257300],[1]]'
-  const currentTick = '257301'
-  const timeSinceLastExecution = '5600'
-  const result = myModule.execute
-  (JSON.stringify(candles2), positions, currentTick, timeSinceLastExecution);
-  expect(result).not.toEqual('continue')
-});
-
-test
-("Can return continue for active trigger", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Price leaves active range",
-      "strategy": "Classic",
-      "liquidityShape": "Linear",
-      "poolFee": 500,
-      "period":6,
-      "standardDeviations":2.0
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257251'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute(//...[JSON.stringify(candles2), positions])
-    JSON.stringify(candles2),
-    positions, 
-    currentTick,
-    timeSinceLastExecution);
-    expect(result).toEqual('continue')
-  });
-
-  test("Can return positions for active trigger", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Price leaves active range",
-      "strategy": "Classic",
-      "liquidityShape": "Linear",
-      "poolFee": 3000,
-      "placementType": "Position over current price",
-      "period":6,
-      "standardDeviations":2.0,
-      "positionSize": 600
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257301'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute
-    (JSON.stringify(candles2), positions, currentTick, timeSinceLastExecution);
-    expect(result).not.toEqual('continue')
+describe('AssemblyScript package surface', () => {
+  it('compiles the package with the modern AssemblyScript toolchain', () => {
+    execFileSync('npm', ['run', 'asbuild'], {
+      cwd: path.resolve(__dirname, '..'),
+      stdio: 'pipe',
+    });
   });
 
-  test("Can return continue for distance trigger", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Current Price set distance from center of positions",
-      "tickDistanceFromCenter": 100,
-      "strategy": "Classic",
-      "liquidityShape": "Linear",
-      "poolFee": 3000,
-      "placementType": "Position over current price",
-      "period":6,
-      "standardDeviations":2.0,
-      "positionSize": 600
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257251'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute
-    (JSON.stringify(candles2), positions, currentTick, timeSinceLastExecution);
-    expect(result).toEqual('continue')
+  it('compiles a Panoptic consumer using exported DTOs and wrappers', () => {
+    execFileSync(
+      path.resolve(__dirname, '../node_modules/.bin/asc'),
+      [path.resolve(__dirname, 'fixtures/panoptic-consumer.ts'), '--config', path.resolve(__dirname, '../asconfig.json'), '--noEmit'],
+      {
+        cwd: path.resolve(__dirname, '..'),
+        stdio: 'pipe',
+      },
+    );
   });
 
-  test("Can return positions for distance trigger", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Current Price set distance from center of positions",
-      "tickDistanceFromCenter": 100,
-      "strategy": "Classic",
-      "liquidityShape": "Linear",
-      "poolFee": 3000,
-      "placementType": "Position over current price",
-      "period":6,
-      "standardDeviations":2.0,
-      "positionSize": 600
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257301'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute
-    (JSON.stringify(candles2), positions, currentTick, timeSinceLastExecution);
-    expect(result).not.toEqual('continue')
-  });
+  it('preserves json-as runtime compatibility for legacy prices and dynamic Merkle proof keys', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const wasmPath = path.join(os.tmpdir(), 'strategy-utils-json-compat.fixture.wasm');
 
-  test("Can return continue for percentage trigger", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Price moves percentage of active range away",
-      "percentageOfPositionRangeToTrigger": 1,
-      "strategy": "Classic",
-      "liquidityShape": "Linear",
-      "poolFee": 3000,
-      "placementType": "Position over current price",
-      "period":6,
-      "standardDeviations":2.0,
-      "positionSize": 600
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257251'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute
-    (JSON.stringify(candles2), positions, currentTick, timeSinceLastExecution);
-    expect(result).toEqual('continue')
-  });
+    execFileSync(
+      path.resolve(repoRoot, 'node_modules/.bin/asc'),
+      [
+        path.resolve(__dirname, 'fixtures/json-compat.ts'),
+        '--config',
+        path.resolve(repoRoot, 'asconfig.json'),
+        '--outFile',
+        wasmPath,
+        '--exportRuntime',
+      ],
+      {
+        cwd: repoRoot,
+        stdio: 'pipe',
+      },
+    );
 
-  test("Can return positions for percentage trigger", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Price moves percentage of active range away",
-      "percentageOfPositionRangeToTrigger": 1,
-      "strategy": "Classic",
-      "liquidityShape": "Linear",
-      "poolFee": 3000,
-      "placementType": "Position over current price",
-      "period":6,
-      "standardDeviations":2.0,
-      "positionSize": 600
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257301'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute
-    (JSON.stringify(candles2), positions, currentTick, timeSinceLastExecution);
-    expect(result).not.toEqual('continue')
-  });
+    const wasm = loader.instantiateSync(fs.readFileSync(wasmPath), {});
+    const { parseStringifiedPrices, roundTripMerkleProofActions, __getString, __newString } = wasm.exports;
 
-  test("Can return continue for one way inactive - active", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Price moves one way past positions",
-      "triggerWhenOver": true,
-      "poolFee": 3000,
-      "placementType": "Position over current price",
-      "period":6,
-      "standardDeviations":2.0,
-      "positionSize": 600
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257251'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute
-    (JSON.stringify(candles2), positions, currentTick, timeSinceLastExecution);
-    expect(result).toEqual('continue')
-  });
+    expect(__getString(parseStringifiedPrices())).toBe('ok');
 
-  test("Can return continue for one way inactive - below", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Price moves one way past positions",
-      "triggerWhenOver": true,
-      "strategy": "Classic",
-      "liquidityShape": "Linear",
-      "poolFee": 3000,
-      "placementType": "Position over current price",
-      "triggerWhenOver": true,
-      "period":6,
-      "standardDeviations":2.0,
-      "positionSize": 600
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257000'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute
-    (JSON.stringify(candles2), positions, currentTick, timeSinceLastExecution);
-    expect(result).toEqual('continue')
-  });
+    const input = JSON.stringify({
+      leafs: [],
+      proofsByAction: {
+        approveToken: ['0xaaa'],
+        rebalanceVault: ['0xbbb', '0xccc'],
+      },
+      proofsByDigest: {
+        '0x111': ['0xddd'],
+      },
+    });
 
-  test("Can return positions for one way inactive - above", async () => {        
-    const config = `{
-      "elapsedTendTime": 604800,
-      "triggerStyle": "Price moves one way past positions",
-      "triggerWhenOver": true,
-      "strategy": "Bollinger Band",
-      "liquidityShape": "Linear",
-      "poolFee": 500,
-      "placementType": "Position over current price",
-      "triggerWhenOver": true,
-      "lookback": 12,
-      "period":6,
-      "standardDeviations":2.0,
-    }`
-    myModule.initialize(config);
-    const positions = '[[257100],[257300],[1]]'
-    const currentTick = '257301'
-    const timeSinceLastExecution = '5600'
-    const result = myModule.execute
-    (JSON.stringify([...candles2]), positions, currentTick, timeSinceLastExecution);
-    expect(result).not.toEqual('continue')
+    const output = JSON.parse(__getString(roundTripMerkleProofActions(__newString(input))));
+    expect(output.approveToken).toStrictEqual(['0xaaa']);
+    expect(output.rebalanceVault).toStrictEqual(['0xbbb', '0xccc']);
   });
-    });
-});
+});

package/assembly/utils/CandleGenerator.ts

@@ -1,60 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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/SlidingWindow.ts

@@ -1,59 +0,0 @@
-export class SlidingWindow<T> {
-    private data: Array<T>;
-    private windowSize: i32;
-    private formula: (window: Array<T>) => T;
-    private cursor: i32;
-
-    constructor(windowSize: i32, formula: (window: Array<T>) => T) {
-        if (windowSize < 1) {
-            throw new Error("windowSize must be greater than 0");
-        }
-        if (formula === null) {
-            throw new Error("formula function must be provided");
-        }
-        this.windowSize = windowSize;
-        this.formula = formula;
-        this.data = new Array<T>(windowSize);
-        this.cursor = 0;
-    }
-
-    addValue(value: T): void {
-        this.data[this.cursor] = value;
-        this.cursor = (this.cursor + 1) % this.windowSize;
-    }
-
-    getLastValue(): T {
-        let index = this.cursor === 0 ? this.windowSize - 1 : this.cursor - 1;
-        return this.data[index];
-    }
-
-    clear(): void {
-        this.data.fill(null);
-    }
-
-    setWindowSize(size: i32): void {
-        if (size < 1) {
-            throw new Error("windowSize must be greater than 0");
-        }
-        this.windowSize = size;
-        this.data = new Array<T>(size);
-    }
-
-    getWindow(): Array<T> {
-        let result = new Array<T>(this.windowSize);
-        for (let i = 0; i < this.windowSize; i++) {
-            let index = (this.cursor + i) % this.windowSize;
-            result[i] = this.data[index];
-        }
-        return result;
-    }
-
-    getFormulaResult(): T {
-        let window = this.getWindow();
-        return this.formula(window);
-    }
-
-    isStable(): bool {
-        return this.data.length >= this.windowSize;
-    }
-}

package/assembly/utils/env.ts

@@ -1,23 +0,0 @@
-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);
-}