@steerprotocol/strategy-utils 1.1.1 → 2.0.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+### [1.1.2-alpha.1](https://github.com/SteerProtocol/strategy-utils-assemblyscript/compare/v1.1.1...v1.1.2-alpha.1) (2022-08-15)
+
+
+### Bug Fixes
+
+* :ambulance: Specific Index for parse prices ([0940640](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/09406407c7cb12bca2585976f3269414d9be731b))
+
+### [1.1.1-alpha.1](https://github.com/SteerProtocol/strategy-utils-assemblyscript/compare/v1.1.0...v1.1.1-alpha.1) (2022-07-26)
+
+
+
+### Bug Fixes
+
+* **devops:** :bug: Fix tests ([a2bb4d6](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/a2bb4d6bdc5e3dc8bbcf6be6f26c74b8167675a7))
+
 ## [1.1.0](https://github.com/SteerProtocol/strategy-utils-assemblyscript/compare/v1.0.0...v1.1.0) (2022-07-26)
 
 

package/assembly/utils/MovingAverages.ts

@@ -1,6 +1,3 @@
-
-
-// WARNING: classes will initially be allocated 1 page of memory, you will likely need to add size or flatten these classes
 export class SMA {
   private readonly prices: f32[] = [];
   private interval: i32 = 0;
@@ -15,7 +12,6 @@ export class SMA {
     return this.result;
   }
 
-
   update(price: f32): void {
     this.prices.push(price);
 
@@ -26,11 +22,10 @@ export class SMA {
     if (this.prices.length === this.interval) {
       let result = f32(0);
       for (let priceIndex = 0; priceIndex < this.prices.length; priceIndex++) {
-        result = result + this.prices[priceIndex]
+        result = result + this.prices[priceIndex];
       }
       this.result = result / f32(this.prices.length || 1);
     }
-
   }
 }
 
@@ -39,8 +34,7 @@ export class EMA {
   private interval: i32 = 0;
   private result: f32;
   private multiplier: i32;
-  private prevEMA : f32
-
+  private prevEMA: f32;
 
   constructor(interval: i32, multiplier: i32) {
     this.interval = interval;
@@ -56,18 +50,17 @@ export class EMA {
 
     if (this.prices.length > this.interval) {
       this.prices.shift();
-    }  // remove oldest price
+    } // remove oldest price
 
     if (!this.prevEMA) {
       this.prevEMA = price;
     }
 
+    let p1 = price * (f32(this.multiplier) / (1 + f32(this.interval)));
+    let p2 =
+      this.prevEMA * (1 - f32(this.multiplier) / (1 + f32(this.interval)));
 
-    let p1 = price * (f32(this.multiplier) / (1 + f32(this.interval)))
-    let p2 = this.prevEMA * (1 - (f32(this.multiplier) / (1 + f32(this.interval))))
-    
-    this.result = f32(p1 + p2)
+    this.result = f32(p1 + p2);
     this.prevEMA = this.result;
-
   }
-}
+}

package/assembly/utils/Ranges.ts

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

package/assembly/utils/UniswapLiquidityUtils.ts

@@ -1,48 +1,60 @@
-import {Position } from "./types";
+import { Position } from "./types";
 
-export function getTickSpacing(poolFee: i32): i32{
-    let spacing = 0;
-    switch (poolFee){
-        case 100:
-            spacing = 1;
-            break;
-        case 500:
-            spacing = 10;
-            break;
-        case 3000:
-            spacing = 60;
-            break;
-        default:
-            spacing = 200;
-    }
-    return spacing;
+export function getTickSpacing(poolFee: i32): i32 {
+  let spacing = 0;
+  switch (poolFee) {
+    case 100:
+      spacing = 1;
+      break;
+    case 500:
+      spacing = 10;
+      break;
+    case 3000:
+      spacing = 60;
+      break;
+    default:
+      spacing = 200;
+  }
+  return spacing;
 }
 
 // Function shaped for making positions with the UniLiquidityManager contract for ease
-export function renderULMResult(positions: Array<Position>): string {
+export function renderULMResult(
+  positions: Array<Position>,
+  totalLiquidity1e4: number
+): string {
+  // Construct necessary object
+  const lowerTicks: Array<i32> = [];
+  const upperTicks: Array<i32> = [];
+  const weights: Array<i32> = [];
 
-    // Construct necessary object
-    const lowerTicks: Array<i32> = []
-    const upperTicks: Array<i32> = []
-    const weights: Array<i32> = []
+  for (let i = 0; i < positions.length; i++) {
+    lowerTicks.push(positions[i].startTick);
+    upperTicks.push(positions[i].endTick);
+    weights.push(positions[i].weight);
+  }
 
-    for (let i = 0; i < positions.length; i++) {
-        lowerTicks.push(positions[i].startTick)
-        upperTicks.push(positions[i].endTick)
-        weights.push(positions[i].weight)
-    }
-
-    return `{"functionName":"tend(uint256,(int24[],int24[],uint16[]),bytes)",
+  return (
+    `{"functionName":"tend(uint256,(int24[],int24[],uint16[]),bytes)",
     "typesArray":["uint256","tuple(int24[],int24[],uint16[])","bytes"],
-    "valuesArray":[10000, [[`+lowerTicks.toString() +'],['+upperTicks.toString()+'],['+ weights.toString() +`]], "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000000000000000ffffffffffffffffffffffffffffffffffffffff"]
+    "valuesArray":[` +
+    totalLiquidity1e4.toString() +
+    `}, [[` +
+    lowerTicks.toString() +
+    "],[" +
+    upperTicks.toString() +
+    "],[" +
+    weights.toString() +
+    `]], "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000000000000000ffffffffffffffffffffffffffffffffffffffff"]
     }`
-    // The bytes value here is a placeholder for encoding that gets replaced with time-sensitive data upon execution. It will actually be the swap amount for rebalancing (int256) and slippage limit (uint160)
+  );
+  // The bytes value here is a placeholder for encoding that gets replaced with time-sensitive data upon execution. It will actually be the swap amount for rebalancing (int256) and slippage limit (uint160)
 }
 
 // TODO: Might need to be rewritten for assets
 // Price must be in the native token
 // token0 for token1
 export function getTickFromPrice(price: f32): f32 {
-    const tick = Math.log(price) / Math.log(f32(1.0001));
-    return f32(tick);
-}
+  const tick = Math.log(price) / Math.log(f32(1.0001));
+  return f32(tick);
+}

package/assembly/utils/types/Candle.ts

@@ -0,0 +1,41 @@
+import * as JSON from '@serial-as/json'
+import {console} from '../console'
+
+@serializable
+export class Candle{
+  timestamp: i64 = 0; 
+  high: number = 0.0; 
+  low: number  = 0.0;
+  open: number = 0.0;
+  close: number = 0.0;
+
+  constructor(timestamp: i64, high: number, low: number, open: number, close: number) {
+    this.timestamp = timestamp;
+    this.high = high;
+    this.low = low;
+    this.open = open;
+    this.close = close;
+  }
+
+  toString(): string {
+    return JSON.stringify(this);
+  }
+}
+
+/**
+ * 
+ * @param _data data connector data array
+ * @returns 
+ */
+export function parsePrices(_data: string): Array<Candle> {
+  return parseCandles(_data);
+}
+
+export function parseCandles(_data: string): Array<Candle> {
+  // Parse an object using the JSON object
+  let parsed: Array<Candle> = JSON.parse<Array<Candle>>(_data);
+
+  console.log('parsed: ' + parsed.toString())
+
+  return parsed;
+}

package/assembly/utils/types/index.ts

@@ -1,2 +1,2 @@
 export * from './Position';
-export * from './Price';
+export * from './Candle';

package/index.js

@@ -9,6 +9,6 @@ const imports = {
   }
 };
 
-const asBindInstance = AsBind.instantiateSync(fs.readFileSync(__dirname + "/build/optimized.wasm"), imports)
+const asBindInstance = AsBind.instantiateSync(fs.readFileSync(__dirname + "/build/untouched.wasm"), imports)
 
 module.exports = asBindInstance.exports;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@steerprotocol/strategy-utils",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "description": "Strategy utilities library for Steer Protocol strategies",
   "main": "assembly/index.ts",
   "types": "assembly/index.ts",
   "scripts": {
     "test": "yarn jest",
-    "asbuild:untouched": "asc assembly/index.ts --target debug --exportRuntime --transform as-bind",
-    "asbuild:optimized": "asc assembly/index.ts --target release --exportRuntime --transform as-bind",
+    "asbuild:untouched": "asc assembly/index.ts --target debug --exportRuntime --transform as-bind --transform @serial-as/transform",
+    "asbuild:optimized": "asc assembly/index.ts --target release --exportRuntime --transform as-bind --transform @serial-as/transform",
     "asbuild": "npm run asbuild:untouched && npm run asbuild:optimized",
     "docs": "typedoc --tsconfig ./tsconfig.json",
     "strategy": "yarn asbuild && yarn test",
@@ -21,6 +21,7 @@
     "@babel/preset-typescript": "^7.14.5",
     "@semantic-release/changelog": "^5.0.1",
     "@semantic-release/git": "^9.0.0",
+    "@serial-as/json": "1.0.2",
     "@steerprotocol/base-strategy": "^0.0.2",
     "as-bind": "^0.8.0",
     "assemblyscript-json": "^1.1.0",

package/tests/index.test.ts

@@ -3,21 +3,26 @@ const myModule = require("../index");
 describe("WASM Module", () => {
   describe("keltnerChannels", () => {
     it("Price should ", async () => {
-      const price =  new myModule.Price(1,2,3,4);
+      const price =  new myModule.Candle("123",1,2,3,4);
       expect(price.high).toBe(1);
       expect(price.low).toBe(2);
       expect(price.open).toBe(3);
       expect(price.close).toBe(4);
     });
     it("True average should compute properly", async () => {
-      const prices =  [new myModule.Price(1,2,3,4),new myModule.Price(2,3,4,5)];
+      const prices =  [new myModule.Candle("12342343",1,2,3,4),new myModule.Candle("12342343",2,3,4,5)];
       const trueAverage = myModule.getAverageTrueRange(prices, 1);
       expect(trueAverage).toBe(2);
     });
     it("True average should support decimals ", async () => {
-      const prices =  [new myModule.Price(6.1,4.2,2.5,1.11),new myModule.Price(41,32,41,15)];
+      const prices =  [new myModule.Candle("12342343",6.1,4.2,2.5,1.11),new myModule.Candle("12342343",41,32,41,15)];
       const trueAverage = myModule.getAverageTrueRange(prices, 1);
       expect(trueAverage).toBe(39.88999938964844)
     });
+    it("Should parse candles ", async () => {
+      const candles =  '[{"timestamp":"12312312123","high":6.1,"low":4.2,"open":2.5,"close":1.11},{"timestamp":"12312312123","high":41.1,"low":32.1,"open":41.2,"close":15.1}]'
+      const candlesArray = myModule.parseCandles(candles);
+      expect(candlesArray.length).toBe(2)
+    });
   });
 });

package/assembly/utils/types/Price.ts

@@ -1,60 +0,0 @@
-import { JSON } from "assemblyscript-json";
-
-export class Price {
-  constructor(
-    public high: f32,
-    public low: f32,
-    public open: f32,
-    public close: f32
-  ) {}
-}
-
-export function parsePrices(_prices: String): Array<Price> {
-  const prices = _prices;
-  // Parse an object using the JSON object
-  let jsonObj: JSON.Obj = <JSON.Obj>JSON.parse(prices);
-  const result: Array<Price> = [];
-
-  const data_arr = <JSON.Arr>jsonObj.getArr("data");
-  if (data_arr == null) {throw new Error()};
-  // First and only data result for this strategy is the candles
-  const val = <JSON.Arr>data_arr._arr[0]
-  if (val != null) {
-      if (val.isArr) {
-      const pricesArray = (<JSON.Arr>val).valueOf();
-
-      for (let priceIndex = 0; priceIndex < pricesArray.length; priceIndex++) {
-          const price = pricesArray[priceIndex];
-
-          const candle = <JSON.Obj>JSON.parse(price.toString());
-
-          if (candle.isObj) {
-          const cl = candle.getValue("close");
-          const hi = candle.getValue("high");
-          const lo = candle.getValue("low");
-          const op = candle.getValue("open");
-
-          if (cl && hi && lo && op) {
-              //@ts-ignore
-              const close = f32(Number.parseFloat(cl.toString()));
-              //@ts-ignore
-              const high = f32(Number.parseFloat(hi.toString()));
-              //@ts-ignore
-              const low = f32(Number.parseFloat(lo.toString()));
-              //@ts-ignore
-              const open = f32(Number.parseFloat(op.toString()));
-
-              const obj: Price = new Price(high, low, open, close);
-
-              result.push(obj);
-          }
-          }
-
-          return result;
-      }
-      }
-      return [];
-  } else {
-      return [];
-  }
-}