@steerprotocol/strategy-utils 3.1.1 → 3.2.0

package/assembly/utils/Math.ts

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

package/assembly/utils/MovingAverages.ts

@@ -1,18 +1,22 @@
+
+
+// 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: f64[] = [];
+  private readonly prices: f32[] = [];
   private interval: i32 = 0;
-  private result: f64 = 0
-  // private prevEMA: f64;
+  private result: f32;
+  private prevEMA: f32;
 
   constructor(interval: i32) {
     this.interval = interval;
   }
 
-  getResult(): f64 {
+  getResult(): f32 {
     return this.result;
   }
 
-  update(price: f64): void {
+
+  update(price: f32): void {
     this.prices.push(price);
 
     if (this.prices.length > this.interval) {
@@ -20,47 +24,50 @@ export class SMA {
     }
 
     if (this.prices.length === this.interval) {
-      let result = f64(0);
+      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 / f64(this.prices.length || 1);
+      this.result = result / f32(this.prices.length || 1);
     }
+
   }
 }
 
 export class EMA {
-  private readonly prices: f64[] = [];
+  private readonly prices: f32[] = [];
   private interval: i32 = 0;
-  private result: f64 = 0
+  private result: f32;
   private multiplier: i32;
-  private prevEMA: f64 = 0
+  private prevEMA : f32
+
 
   constructor(interval: i32, multiplier: i32) {
     this.interval = interval;
     this.multiplier = multiplier;
   }
 
-  getResult(): f64 {
+  getResult(): f32 {
     return this.result;
   }
 
-  update(price: f64): void {
+  update(price: f32): void {
     this.prices.push(price);
 
     if (this.prices.length > this.interval) {
       this.prices.shift();
-    } // remove oldest price
+    }  // remove oldest price
 
     if (!this.prevEMA) {
       this.prevEMA = price;
     }
 
-    let p1 = price * (f64(this.multiplier) / (1 + f64(this.interval)));
-    let p2 =
-      this.prevEMA * (1 - f64(this.multiplier) / (1 + f64(this.interval)));
 
-    this.result = f64(p1 + p2);
+    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.prevEMA = this.result;
+
   }
-}
+}

package/assembly/utils/Ranges.ts

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

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

@@ -1,8 +1,6 @@
 export * from './Math';
 export * from './MovingAverages';
 export * from './Ranges';
-export * from './SlidingWindow';
+export * from './UniswapLiquidityUtils';
 export * from './console';
-export * from './env';
 export * from './types';
-export * from './triggers'

package/assembly/utils/types/Position.ts

@@ -1,6 +1,3 @@
-import { JSON } from 'json-as/assembly';
-
-@serializable
 export class Position 
 {
     constructor(

package/assembly/utils/types/Price.ts

@@ -0,0 +1,54 @@
+import { JSON } from "json-as/assembly";
+
+@serializable
+export class Price {
+  constructor(
+    public high: f32 = 0,
+    public low: f32 = 0,
+    public open: f32 = 0,
+    public close: f32 = 0
+  ) {}
+}
+
+function parsePriceField(candle: JSON.Obj, key: string): f32 {
+  const value = candle.get(key);
+
+  if (value === null) {
+    return 0;
+  }
+
+  if (value!.type == JSON.Types.String) {
+    return f32.parse(value!.get<string>());
+  }
+
+  return f32.parse(value!.toString());
+}
+
+export function parsePrices(_prices: string): Array<Price> {
+  const payload = JSON.parse<JSON.Obj>(_prices);
+  const dataValue = payload.get("data");
+
+  if (dataValue === null) {
+    return [];
+  }
+
+  const data = dataValue!.get<JSON.Arr>();
+  if (data.length == 0) {
+    return [];
+  }
+
+  const candles = data.getAs<JSON.Arr>(0);
+  const result = new Array<Price>();
+
+  for (let priceIndex = 0; priceIndex < candles.length; priceIndex++) {
+    const candle = candles.getAs<JSON.Obj>(priceIndex);
+    result.push(new Price(
+      parsePriceField(candle, "high"),
+      parsePriceField(candle, "low"),
+      parsePriceField(candle, "open"),
+      parsePriceField(candle, "close"),
+    ));
+  }
+
+  return result;
+}

package/assembly/utils/types/index.ts

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

package/index.js

@@ -1,14 +1,3 @@
-// const fs = require("fs");
-// import * as AsBind from "as-bind/dist/as-bind.cjs.js";
-
-// const imports = {
-//   console: { // File which you are injecting
-//     log(strPtr) {
-//       console.log(strPtr)
-//     }
-//   }
-// };
-
-// const asBindInstance = AsBind.instantiateSync(fs.readFileSync(__dirname + "/build/untouched.wasm"), imports)
-
-// module.exports = asBindInstance.exports;
+throw new Error(
+  '@steerprotocol/strategy-utils is an AssemblyScript source package. Import from assembly/index.ts in AssemblyScript strategies.',
+);

package/package.json

@@ -1,42 +1,38 @@
 {
   "name": "@steerprotocol/strategy-utils",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Strategy utilities library for Steer Protocol strategies",
   "main": "assembly/index.ts",
   "types": "assembly/index.ts",
   "scripts": {
     "test": "yarn jest",
-    "asbuild:debug": "asc assembly/index.ts --target debug",
-    "asbuild:release": "asc assembly/index.ts --target release",
-    "asbuild": "npm run asbuild:debug && npm run asbuild:release",
-    "start": "npx serve .",
-    "docs": "typedoc --tsconfig ./tsconfig.json",
+    "asbuild:untouched": "asc assembly/index.ts --target debug --exportRuntime",
+    "asbuild:optimized": "asc assembly/index.ts --target release --exportRuntime",
+    "asbuild": "npm run asbuild:untouched && npm run asbuild:optimized",
+    "docs": "node scripts/build-docs.js",
     "strategy": "yarn asbuild && yarn test",
     "semantic-release": "semantic-release",
-    "commit": "cz",
-    "postinstall": "patch-package"
+    "commit": "cz"
   },
   "author": "Derek Barrera <derekbarrera@gmail.com>",
   "license": "ISC",
   "dependencies": {
+    "@assemblyscript/loader": "^0.28.19",
     "@babel/preset-typescript": "^7.14.5",
     "@semantic-release/changelog": "^5.0.1",
     "@semantic-release/git": "^9.0.0",
-    "@steerprotocol/app-loader": "^0.2.2",
-    "@steerprotocol/base-strategy": "0.1.0",
-    "as-bignum": "^0.2.23",
+    "@steerprotocol/base-strategy": "^0.0.2",
     "commitizen": "^4.2.4",
     "conventional-changelog-conventionalcommits": "^4.6.0",
-    "json-as": "^0.5.43",
-    "patch-package": "^8.0.0",
     "typescript": "^4.3.5",
+    "json-as": "^1.2.6",
     "visitor-as": "^0.11.4"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.14.8",
     "@types/jest": "^27.0.1",
     "@types/node": "^16.11.11",
-    "assemblyscript": "^0.27.0",
+    "assemblyscript": "^0.28.19",
     "babel-core": "^6.26.3",
     "babel-jest": "^27.0.6",
     "cz-conventional-changelog": "3.3.0",

package/scripts/build-docs.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const path = require('path');
+
+const docsDir = path.join(process.cwd(), 'docs');
+fs.mkdirSync(docsDir, { recursive: true });
+
+const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+const files = [
+  'assembly/index.ts',
+  'assembly/utils/index.ts',
+  'assembly/panoptic/index.ts',
+  'assembly/panoptic/methods.ts',
+  'assembly/panoptic/types.ts',
+  'assembly/panoptic/host.ts',
+].filter((file) => fs.existsSync(file));
+
+const methodFile = 'assembly/panoptic/methods.ts';
+const methods = fs.existsSync(methodFile)
+  ? Array.from(fs.readFileSync(methodFile, 'utf8').matchAll(/export const ([A-Z0-9_]+) = \"([^\"]+)\";/g)).map((match) => ({
+      name: match[1],
+      method: match[2],
+    }))
+  : [];
+
+const escapeHtml = (value) => value
+  .replace(/&/g, '&')
+  .replace(/</g, '&lt;')
+  .replace(/>/g, '&gt;')
+  .replace(/\"/g, '&quot;');
+
+const html = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(packageJson.name)} ${escapeHtml(packageJson.version)}</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; margin: 2rem; line-height: 1.5; color: #1f2937; }
+    main { max-width: 960px; }
+    code { background: #f3f4f6; padding: 0.125rem 0.25rem; border-radius: 4px; }
+    table { border-collapse: collapse; width: 100%; margin-top: 1rem; }
+    th, td { border: 1px solid #d1d5db; padding: 0.5rem; text-align: left; }
+    th { background: #f9fafb; }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>${escapeHtml(packageJson.name)} ${escapeHtml(packageJson.version)}</h1>
+    <p>AssemblyScript source package for Steer strategy utilities.</p>
+    <h2>Import</h2>
+    <pre><code>import { PanopticMethods, erc20ApproveFragment } from "@steerprotocol/strategy-utils/assembly";</code></pre>
+    <h2>Entrypoints</h2>
+    <ul>
+      ${files.map((file) => `<li><code>${escapeHtml(file)}</code></li>`).join('\n      ')}
+    </ul>
+    <h2>Panoptic RuntimeAdapter Methods</h2>
+    <table>
+      <thead><tr><th>Constant</th><th>Method</th></tr></thead>
+      <tbody>
+        ${methods.map(({ name, method }) => `<tr><td><code>${escapeHtml(name)}</code></td><td><code>${escapeHtml(method)}</code></td></tr>`).join('\n        ')}
+      </tbody>
+    </table>
+  </main>
+</body>
+</html>
+`;
+
+fs.writeFileSync(path.join(docsDir, 'index.html'), html);

package/tests/fixtures/json-compat.ts

@@ -0,0 +1,30 @@
+import { JSON } from "json-as/assembly";
+import { MerkleArtifactDto } from "../../assembly/panoptic/types";
+import { parsePrices } from "../../assembly/utils/types/Price";
+
+export function parseStringifiedPrices(): string {
+  const prices = parsePrices('{"data":[[{"high":"123.4","low":"120.1","open":"121.2","close":"122.3"},{"high":124.5,"low":121.2,"open":122.3,"close":123.4}]]}');
+
+  if (prices.length != 2) {
+    return "bad-length:" + prices.length.toString();
+  }
+
+  if (prices[0].high < 123.39 || prices[0].high > 123.41) {
+    return "bad-string-high:" + prices[0].high.toString();
+  }
+
+  if (prices[0].close < 122.29 || prices[0].close > 122.31) {
+    return "bad-string-close:" + prices[0].close.toString();
+  }
+
+  if (prices[1].high < 124.49 || prices[1].high > 124.51) {
+    return "bad-number-high:" + prices[1].high.toString();
+  }
+
+  return "ok";
+}
+
+export function roundTripMerkleProofActions(input: string): string {
+  const artifact = JSON.parse<MerkleArtifactDto>(input);
+  return JSON.stringify<Map<string, string[]>>(artifact.proofsByAction);
+}

package/tests/fixtures/panoptic-consumer.ts

@@ -0,0 +1,24 @@
+import {
+  DynamicJobFragmentDto,
+  Erc20ApproveFragmentRequestDto,
+  PanopticMethods,
+  erc20ApproveFragment,
+} from "../../assembly";
+
+export function buildTypedPanopticRequest(): string {
+  const request = new Erc20ApproveFragmentRequestDto();
+  request.args.token = "0x00000000000000000000000000000000000000a0";
+  request.args.spender = "0x00000000000000000000000000000000000000b0";
+  request.args.amount = "100";
+
+  return PanopticMethods.ERC20_APPROVE_FRAGMENT
+    + ":" + request.args.token
+    + ":" + request.args.spender
+    + ":" + request.args.amount;
+}
+
+export function compileTypedPanopticWrapper(): string {
+  const response = erc20ApproveFragment(new Erc20ApproveFragmentRequestDto());
+  const fragment: DynamicJobFragmentDto = response.result;
+  return fragment.value;
+}