@steerprotocol/strategy-utils 0.0.3 → 1.1.1

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [1.1.0](https://github.com/SteerProtocol/strategy-utils-assemblyscript/compare/v1.0.0...v1.1.0) (2022-07-26)
+
+
+### Features
+
+* :sparkles: Additional Helper functions ([a783b06](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/a783b06c08ce11e50469c15e3f53224adf9710bb))
+
+
+### Bug Fixes
+
+* :bug: Hot Fix sync ([e635a70](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/e635a70951463271f227e996408d2bf4bb9c633d))
+
+## 1.0.0 (2022-07-14)
+
+
+### Features
+
+* :sparkles: More utilities ([0bda6dd](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/0bda6dd58f395f09b252365f677d397b87f04e80))
+
 ## 1.0.0-alpha.1 (2021-12-09)
 
 

package/assembly/index.ts

@@ -1 +1 @@
-export * from './utils'
+export * from './utils';

package/assembly/utils/Math.ts

@@ -1,4 +1,4 @@
-export function getMax(arr: Array<f32>): f32 {
+export function _getMax(arr: Array<f32>): f32 {
     let max = arr[0];
     for (let i = 1; i < arr.length; i++) {
       if (arr[i] > max) {
@@ -6,4 +6,38 @@ export function getMax(arr: Array<f32>): f32 {
       }
     }
     return max;
-  }
+  }
+
+  export function getMax(a: f32, b: f32): f32 {
+    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 _standardDeviation(list:f32[]): f32 {
+  const mean = _mean(list)
+  const sqrdDiff: f32[] = []
+  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)
+}
+
+// SMA simple moving average
+export function _mean(list: f32[]): f32 {
+  const length = list.length;
+  let total: f32 = 0.0;
+  for (let i = 0; i < length; i++){
+      total += list[i]
+  }
+  return total / f32(length)
+}

package/assembly/utils/MovingAverages.ts

@@ -1,4 +1,6 @@
 
+
+// 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;

package/assembly/utils/Ranges.ts

@@ -1,5 +1,5 @@
-import { Price } from "./Price";
-import { getMax } from "./Math";
+import { Price } from "./types/Price";
+import { getMax, _mean, _getMax } from "./Math";
 
 export function getAverageTrueRange(prices: Array<Price>, interval: i32): f32 {
     let rangeSum: f32 = 0;
@@ -14,11 +14,36 @@ export function getAverageTrueRange(prices: Array<Price>, 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([f32(range1), f32(range2), f32(range3)]);
       rangeSum += max;
     }
     
 
     return f32(rangeSum) / f32(prices.length - 1);
 
-  }
+  }
+
+
+  export   function trailingStop(percent: f32, prices: Price[]): f32 {
+    // 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));
+
+    // Return the trailing stop price
+    return 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))));
+  return trueRange;
+}
+
+export function averageTrueRange(prices: Price[]): f32 {
+  const trueRanges: f32[] = []
+  for (let i = 0; i < prices.length; i++) {
+      trueRanges.push(trueRange(prices[i]));
+  }
+  return _mean(trueRanges);
+}

package/assembly/utils/UniswapLiquidityUtils.ts

@@ -0,0 +1,48 @@
+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;
+}
+
+// Function shaped for making positions with the UniLiquidityManager contract for ease
+export function renderULMResult(positions: Array<Position>): string {
+
+    // 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)
+    }
+
+    return `{"functionName":"tend(uint256,(int24[],int24[],uint16[]),bytes)",
+    "typesArray":["uint256","tuple(int24[],int24[],uint16[])","bytes"],
+    "valuesArray":[10000, [[`+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)
+}
+
+// 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);
+}

package/assembly/utils/console.ts

@@ -0,0 +1,9 @@
+declare function log(s: string): void;
+
+export class console {
+    constructor() {}
+
+    static log(s: string): void {
+        log(s);
+    }
+}

package/assembly/utils/index.ts

@@ -1,4 +1,6 @@
 export * from './Math';
 export * from './MovingAverages';
-export * from './Price';
 export * from './Ranges';
+export * from './UniswapLiquidityUtils';
+export * from './console';
+export * from './types';

package/assembly/utils/types/Position.ts

@@ -0,0 +1,8 @@
+export class Position 
+{
+    constructor(
+        public startTick : i32,
+        public endTick : i32,
+        public weight : i32)
+        {}
+}

package/assembly/utils/types/Price.ts

@@ -0,0 +1,60 @@
+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 [];
+  }
+}

package/assembly/utils/types/index.ts

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

package/index.js

@@ -2,7 +2,7 @@ const fs = require("fs");
 import * as AsBind from "as-bind/dist/as-bind.cjs.js";
 
 const imports = {
-  Logger: { // File which you are injecting
+  console: { // File which you are injecting
     log(strPtr) {
       console.log(strPtr)
     }

package/package.json

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

package/assembly/utils/Price.ts

@@ -1,25 +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<JSON.Value>{
-  const prices = _prices;
-  // Parse an object using the JSON object
-  let jsonObj: JSON.Obj = <JSON.Obj>JSON.parse(prices);
-
-  const val = jsonObj.getValue("data");
-  if (val != null) {
-    if (val.isArr) {
-      const pricesArray = (<JSON.Arr>val).valueOf();
-      return pricesArray;
-    }
-  }
-  return [];
-};