@steerprotocol/strategy-utils 3.0.0 → 3.1.2

package/.vscode/settings.json

@@ -0,0 +1,2 @@
+{
+}

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [1.2.0-alpha.3](https://github.com/SteerProtocol/strategy-utils-assemblyscript/compare/v1.2.0-alpha.2...v1.2.0-alpha.3) (2023-08-23)
+
+
+### Features
+
+* :art: Move Config to all RJFS for EDT ([eb63008](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/eb63008fbd9ca9ed3dee9ab81336cce89de5c482))
+
+
+### Bug Fixes
+
+* :ambulance: Object validation ([74b7a05](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/74b7a059f79ea02202e10339c87ebefc5778ffcf))
+* remove type for trigger ([f8c4987](https://github.com/SteerProtocol/strategy-utils-assemblyscript/commit/f8c49877779b82c5265c30c79962947eaa014886))
+
 ## [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)
 
 

package/assembly/utils/index.ts

@@ -5,3 +5,4 @@ export * from './SlidingWindow';
 export * from './console';
 export * from './env';
 export * from './types';
+export * from './triggers'

package/assembly/utils/triggers.ts

@@ -1,4 +1,5 @@
 import { JSON } from "json-as";
+// import { Position } from "@steerprotocol/strategy-utils/assembly";
 import { Position } from "./types";
 
 // NOTE: Trigger functions return true when action should be taken, if false then the strategy can return 'continue' to skip exeuction
@@ -8,28 +9,39 @@ import { Position } from "./types";
   // if (!shouldTriggerExecution(trigger, triggerObj, _positions, _currentTick, _timeSinceLastExecution)) return 'continue'
 
 // Gets active range from the output of LM.getPositions()
-export function parseActiveRange(_positions: string): Position {
-    // _positions will be '[[#,#,#],[#,#,#],[#,#,#]]' presumably. lower, upper, weight
-    // clean up our list by removing spaces and brackets
-    let positions = _positions.replaceAll(' ','');
-    positions = positions.replaceAll('[','');
-    let rangeArray = positions.split(']',2);
-    let startTick = rangeArray[0].split(',')[0];
-    let endRange = rangeArray[1].split(']',2);
-    const endTicks = endRange[0].split(',');
-    let endTick = endTicks[endTicks.length-1]
-    // if trailing comma
-    if (endTick == '') endTick = endTicks[endTicks.length-2]
-    const strArrays = [startTick, endTick];
-    // check null
-    if (strArrays[0] == '' || strArrays[0] == null || strArrays[1] == '' || strArrays[1] == null) {
-        return new Position(0, 0, 0);
-    }
-    // else return normal
-    const lowerTick = i32(parseInt(strArrays[0]));
-    const upperTick = i32(parseInt(strArrays[1]));
+// export function parseActiveRange(_positions: string): Position {
+//     // _positions will be '[[#,#,#],[#,#,#],[#,#,#]]' presumably. lower, upper, weight
+//     // clean up our list by removing spaces and brackets
+//     let positions = _positions.replaceAll(' ','');
+//     positions = positions.replaceAll('[','');
+//     let rangeArray = positions.split(']',2);
+//     let startTick = rangeArray[0].split(',')[0];
+//     let endRange = rangeArray[1].split(']',2);
+//     const endTicks = endRange[0].split(',');
+//     let endTick = endTicks[endTicks.length-1]
+//     // if trailing comma
+//     if (endTick == '') endTick = endTicks[endTicks.length-2]
+//     const strArrays = [startTick, endTick];
+//     // check null
+//     if (strArrays[0] == '' || strArrays[0] == null || strArrays[1] == '' || strArrays[1] == null) {
+//         return new Position(0, 0, 0);
+//     }
+//     // else return normal
+//     const lowerTick = i32(parseInt(strArrays[0]));
+//     const upperTick = i32(parseInt(strArrays[1]));
+//     // weights shouldn't matter in this context, we just want the total active range
+//     return new Position(lowerTick, upperTick, 100);
+// }
+
+export function parseActiveRange(_positions: Array<Position>): Position {
+
+    if (_positions.length == 0) return new Position(0, 0, 0);
+    // get first pos start tick and last pos end
+    let startTick = _positions[0].startTick
+    let endTick = _positions[_positions.length - 1].endTick
+
     // weights shouldn't matter in this context, we just want the total active range
-    return new Position(lowerTick, upperTick, 100);
+    return new Position(startTick, endTick, 100);
 }
 
 export function emptyCurrentPosition(currentPosition: Position): boolean {
@@ -160,10 +172,12 @@ export class TriggerConfigHelper {
     }
 }
 
-export function getTriggerExpectedDataTypes(triggerStyle: TriggerStyle): string[] {
+export function getTriggerExpectedDataTypes(triggerStyle: string): string[] {
+  // get tirggerStyle
+  const style = getTriggerStyle(triggerStyle)
   // currently we use only this list
   const typicalTypes = ["Liquidity Manager Positions", "V3 Pool Current Tick", "Time Since Last Execution"]
-    switch (triggerStyle) {
+    switch (style) {
         case TriggerStyle.DistanceFromCenterOfPositions:
             return typicalTypes;
         case TriggerStyle.PercentageChangeFromPositionRange:
@@ -183,43 +197,14 @@ export function getTriggerExpectedDataTypes(triggerStyle: TriggerStyle): string[
     }
 }
 
-
-export function getExpectedDataTypes(strategyDataConnectors: string[], triggerStyle: string): string {
-  const style = getTriggerStyle(triggerStyle)
-  const triggerDatas = getTriggerExpectedDataTypes(style)
-  const dataList = strategyDataConnectors.concat(triggerDatas)
-  let completeList = '['
-  for (let i: i32 = 0; i < dataList.length; i++) {
-    completeList += (' \"' + dataList[i] + '\"')
-    if (i != dataList.length-1) completeList += ','
-  }
-  completeList += ']'
-  return completeList
-}
-
-// no AS func overloading yet :(
-// export function shouldTriggerExecution_1(triggerStyle: TriggerStyle, triggerOptions: TriggerConfigHelper, dataConnector1: string) : boolean {
-//     // parse options
-//     switch (triggerStyle) {
-//         case TriggerStyle.SpecificPrice:
-//             // parse current tick from dc1
-//             const currentTick = parseInt(dataConnector1)
-//             if (!currentTick) return true
-//             // tick and over
-//             return triggerFromSpecifiedPrice(triggerOptions.tickPriceTrigger, currentTick, triggerOptions.triggerWhenOver)
-//         default:
-//             return true
-//     }
-// }
-
 // currently implemented as :: ulm positions [0], current tick [1], time since last execution [2]
 // as more types are added this logic path with be redone
 export function shouldTriggerExecution(
   _triggerStyle: string, 
   triggerOptions: TriggerConfigHelper, 
-  dataConnector1: string, 
-  dataConnector2: string, 
-  dataConnector3: string) : boolean {
+  dataConnector1: Array<Position>, 
+  dataConnector2: i64, 
+  dataConnector3: i64) : boolean {
 
     // possible dc inputs
     let currentPositionRange: Position;
@@ -234,34 +219,34 @@ export function shouldTriggerExecution(
         case TriggerStyle.DistanceFromCenterOfPositions:
             // parse ulm positions [0], current tick [1]
                   // @ts-ignore
-            timeSinceLastExecution = i64(parseInt(dataConnector3))
+            timeSinceLastExecution = i64((dataConnector3))
             if (timeSinceLastExecution >= i64(triggerOptions.elapsedTendTime)) return true
             currentPositionRange = parseActiveRange(dataConnector1)
-            currentTick = i64(parseInt(dataConnector2))
+            currentTick = i64((dataConnector2))
             return triggerFromDistance(currentPositionRange, triggerOptions.tickDistanceFromCenter, currentTick)
 
         case TriggerStyle.PercentageChangeFromPositionRange:
             // parse ulm positions [0], current tick [1]
-            timeSinceLastExecution = i64(parseInt(dataConnector3))
+            timeSinceLastExecution = i64((dataConnector3))
             if (timeSinceLastExecution >= i64(triggerOptions.elapsedTendTime)) return true
             currentPositionRange= parseActiveRange(dataConnector1)
-            currentTick = i64(parseInt(dataConnector2))
+            currentTick = i64((dataConnector2))
             return triggerFromPercentage(currentPositionRange, triggerOptions.percentageOfPositionRangeToTrigger, currentTick)
 
         case TriggerStyle.PositionsInactive:
             // parse ulm positions [0], current tick [1]
-            timeSinceLastExecution = i64(parseInt(dataConnector3))
+            timeSinceLastExecution = i64((dataConnector3))
             if (timeSinceLastExecution >= i64(triggerOptions.elapsedTendTime)) return true
             currentPositionRange = parseActiveRange(dataConnector1)
-            currentTick = i64(parseInt(dataConnector2))
+            currentTick = i64((dataConnector2))
             return triggerPositionsInactive(currentPositionRange, currentTick)
 
         case TriggerStyle.PricePastPositions:
             // parse ulm positions [0], current tick [1]
-            timeSinceLastExecution = i64(parseInt(dataConnector3))
+            timeSinceLastExecution = i64((dataConnector3))
             if (timeSinceLastExecution >= i64(triggerOptions.elapsedTendTime)) return true
             currentPositionRange = parseActiveRange(dataConnector1)
-            currentTick = i64(parseInt(dataConnector2))
+            currentTick = i64((dataConnector2))
             return triggerPricePastPositions(currentPositionRange, currentTick,  triggerOptions.triggerWhenOver)
         default:
             return true
@@ -296,34 +281,197 @@ function getTriggerName(trigger: TriggerStyle): string {
   }
 }
 
+  function expectedDataTypesHelper(strategyDataConnectors: string[], triggerStyle: string): string[] {
+    // const style = getTriggerStyle(triggerStyle)
+    return strategyDataConnectors.concat(getTriggerExpectedDataTypes(triggerStyle))
+    // return `"expectedDataTypes": {
+    //   "hidden": true,
+    //   "type": "string",
+    //   "default": "${(fullDataTypes).toString()}",
+    //   "const": "${(fullDataTypes).toString()}"
+    // }`
+  }
 
-export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
-    const triggerList = [
-        TriggerStyle.DistanceFromCenterOfPositions,
-        TriggerStyle.None,
-        TriggerStyle.PercentageChangeFromPositionRange,
-        TriggerStyle.PositionsInactive,
-        TriggerStyle.PricePastPositions,
+  // @serializable
+  // export class TriggerInfo {
+  //   name: string = '';
+  //   expectedDataTypes: string[] = [];
+  //   constructor (_name: string, _expectedDataTypes: string[]) {
+  //     this.name = _name
+  //     this.expectedDataTypes = _expectedDataTypes
+  //   }
+  // }
+
+export function triggerPropertyHelper(): string {
+// export function triggerPropertyHelper(strategyDataTypes: string[], omit: TriggerStyle[] = []): string {
+    // const triggerList = [
+    //     TriggerStyle.DistanceFromCenterOfPositions,
+    //     TriggerStyle.None,
+    //     TriggerStyle.PercentageChangeFromPositionRange,
+    //     TriggerStyle.PositionsInactive,
+    //     TriggerStyle.PricePastPositions,
+    // ];
+
+    const triggersObjects: string[] = [
+      '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',
     ];
 
-    const filteredTriggers: string[] = [
+    const triggerStrings = [
       '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'
-    ];
+    ]
 
+    // return `"triggerStyle": {
+    //   "enumNames": ${JSON.stringify(triggerStrings)},
+    //   "enum": ${JSON.stringify(triggersObjects)},
+    //   "type": "string",
+    //   "title": "Logic to trigger new positions",
+    //   "default": "None"
+    // }`;
 
     return `"triggerStyle": {
-      "enum": ${JSON.stringify(filteredTriggers)},
-      "title": "Logic to trigger new positions",
+      "enumNames": [
+          "Trigger when price moves set distance away from center of liquidity range",
+          "Trigger when price leaves active liquidity range",
+          "Trigger when price moves a proportion of active liquidity range away",
+          "Trigger when price moves out of active range only in one direction",
+          "None"
+      ],
+      "enum": [
+        "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"
+      ],
       "type": "string",
+      "title": "Logic to trigger new positions",
       "default": "None"
-    }`;
+  }`
+  }
+
+  export function configDefinitions(): string {
+    return `
+    "elapsedTendTime": {
+        "type": "number",
+        "title": "Max time between tends",
+        "description": "If trigger conditions have not been met for this period of time, the strategy will execute regardless of trigger logic to update vault accounting.",
+        "default": 1209600
+    },
+    "bins": {
+        "type": "number",
+        "title": "Positions",
+        "description": "The max number of positions the strategy will make to achieve the desired curve.",
+        "detailedDescription": "The strategy will attempt to make this number of positions, but can be limited by available range and pool spacing"
+    },
+    "reflect": {
+        "title": "Reflect Curve Over Y-Axis",
+        "type": "boolean",
+        "default": false
+    },
+    "invert": {
+        "title": "Invert Curve Over X-Axis",
+        "type": "boolean",
+        "default": false
+    }`
+  }
+
+  export function triggerDependency(): string {
+    return `"triggerStyle": {
+      "oneOf": [
+          {
+              "properties": {
+                  "triggerStyle": {
+                      "const": "None"
+                  }
+              },
+              "required": []
+          },
+          {
+              "properties": {
+                  "triggerStyle": {
+                      "const": "Current Price set distance from center of positions"
+                  },
+                  "tickDistanceFromCenter": {
+                      "type": "integer",
+                      "title": "Tick Distance",
+                      "description": "The number of basis points (ticks) away from the central price of existing positions",
+                      "detailedDescription": "The trigger mechanism for new positions is based on a fixed number of ticks from the midpoint of the active range. For instance, with a position range of 0-100 and a tick distance set at 75, the trigger points are calculated 75 ticks on either side of the central tick of our positions, which is 50. This establishes a trigger range extending from -25 to 125. Any current tick falling within this range will not prompt execution. The center of this trigger range is dynamically adjusted based on the locations of future positions."
+                  },
+                  "elapsedTendTime": {
+                       "$ref": "#/definitions/elapsedTendTime"
+                  }
+              },
+              "required": [
+                  "tickDistanceFromCenter",
+                  "elapsedTendTime"
+              ]
+          },
+          {
+              "properties": {
+                  "triggerStyle": {
+                      "const": "Price leaves active range"
+                  },
+                  "elapsedTendTime": {
+                       "$ref": "#/definitions/elapsedTendTime"
+                  }
+              },
+              "required": [
+                  "elapsedTendTime"
+              ]
+          },
+          {
+              "properties": {
+                  "triggerStyle": {
+                      "const": "Price moves percentage of active range away"
+                  },
+                  "percentageOfPositionRangeToTrigger": {
+                      "type": "number",
+                      "title": "Percentage of Range",
+                      "description": "Specify the percentage of the total range at which to initiate new positions, where 100% or a value of 1 corresponds to the edge of the range.",
+                      "detailedDescription": "For a position with a range spanning from 0 to 100 ticks, setting this value to 1 will activate the trigger at the outermost bounds of the range. If the value is set to 0.5, the trigger range narrows to between 25 and 75 ticks. Conversely, setting the value to 2 expands the trigger range, extending it from -50 to 150 ticks."
+                  },
+                  "elapsedTendTime": {
+                       "$ref": "#/definitions/elapsedTendTime"
+                  }
+              },
+              "required": [
+                  "percentageOfPositionRangeToTrigger",
+                  "elapsedTendTime"
+              ]
+          },
+          {
+              "properties": {
+                  "triggerStyle": {
+                      "const": "Price moves one way past positions"
+                  },
+                  "triggerWhenOver": {
+                      "type": "boolean",
+                      "title": "Price Moves Higher",
+                      "description": "Set 'True' to initiate new positions when the current price (tick) exceeds the level of existing positions. Conversely, mark it as 'False' if new positions should be established when the price is lower than the current positions.",
+                      "detailedDescription": "When the existing position spans from 0 to 100 ticks, setting the parameter to 'True' will prompt the strategy to execute only if the current tick exceeds 100. In any scenario where the current tick is less than or equal to 100, the strategy will recommend to continue without executing new execution."
+                  },
+                  "elapsedTendTime": {
+                       "$ref": "#/definitions/elapsedTendTime"
+                  }
+              },
+              "required": [
+                  "triggerWhenOver",
+                  "elapsedTendTime"
+              ]
+          }
+      ]
+  }`
   }
 
-  export function allOfTrigger(strategyDataConnectors: string[]): string {
+  export function allOfTrigger(): string {
     return `{
     "if": {
       "properties": {
@@ -333,15 +481,7 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
       }
     },
     "then": {
-      "properties": {
-        "expectedDataTypes": {
-          "const": ${getExpectedDataTypes(strategyDataConnectors, "None")},
-          "default": ${getExpectedDataTypes(strategyDataConnectors, "None")},
-          "hidden": true,
-          "type": "string"
-        }
-      },
-      "required": ["expectedDataTypes"]
+      "required": []
     }
   },
   {
@@ -360,12 +500,6 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
             "description": "The number of ticks (basis points) from center price of positions to trigger setting new positions",
             "detailedDescription": "The static number of ticks from the center of the active range to trigger: if our position goes from 0-100, and we have a tick distance of 75, we will go out 75 ticks both ways from the center of our positions (50). This means we will skip execution only if the current tick is between -25 and 125. Future positions will determine where the center of the trigger range is located."
         },
-        "expectedDataTypes": {
-          "const": ${getExpectedDataTypes(strategyDataConnectors, "Current Price set distance from center of positions")},
-          "default": ${getExpectedDataTypes(strategyDataConnectors, "Current Price set distance from center of positions")},
-          "hidden": true,
-          "type": "string"
-        },
         "elapsedTendTime": {
           "type": "number",
           "title": "Max time between tends",
@@ -373,7 +507,7 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
           "default": 1209600
         }
       },
-      "required": ["tickDistanceFromCenter", "expectedDataTypes", "elapsedTendTime"]
+      "required": ["tickDistanceFromCenter", "elapsedTendTime"]
     }
   },
   {
@@ -386,12 +520,6 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
     },
     "then": {
       "properties": {
-        "expectedDataTypes": {
-          "const": ${getExpectedDataTypes(strategyDataConnectors, "Price leaves active range")},
-          "default": ${getExpectedDataTypes(strategyDataConnectors, "Price leaves active range")},
-          "hidden": true,
-          "type": "string"
-        },
         "elapsedTendTime": {
           "type": "number",
           "title": "Max time between tends",
@@ -399,7 +527,7 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
           "default": 1209600
         }
       },
-      "required": ["expectedDataTypes", "elapsedTendTime"]
+      "required": ["elapsedTendTime"]
     }
   },
   {
@@ -418,12 +546,6 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
             "description": "The percentage of the range away to trigger new positions, 100% or 1 would be at the bounds of the range",
             "detailedDescription": "If you have a simple position ranging from ticks 0 - 100, and you set this value to 1, the trigger range will be the outer bounds. Using 0.5 would make the trigger range 25-75, 2 would make the range -50 - 150."
         },
-        "expectedDataTypes": {
-          "const": ${getExpectedDataTypes(strategyDataConnectors, "Price moves percentage of active range away")},
-          "default": ${getExpectedDataTypes(strategyDataConnectors, "Price moves percentage of active range away")},
-          "hidden": true,
-          "type": "string"
-        },
         "elapsedTendTime": {
           "type": "number",
           "title": "Max time between tends",
@@ -431,7 +553,7 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
           "default": 1209600
         }
       },
-      "required": ["percentageOfPositionRangeToTrigger", "expectedDataTypes", "elapsedTendTime"]
+      "required": ["percentageOfPositionRangeToTrigger", "elapsedTendTime"]
     }
   },
   {
@@ -450,12 +572,6 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
             "description": "True for if the strategy should set new positions when the price (tick) is higher than the current positions, false for lower",
             "detailedDescription": "If our current position ranges from ticks 0 - 100, true will make our bundle execute only when the current tick is higher. Any other case (current tick less than 100) will result in a continue recommendation."
         },
-        "expectedDataTypes": {
-          "const": ${getExpectedDataTypes(strategyDataConnectors, "Price moves one way past positions")},
-          "default": ${getExpectedDataTypes(strategyDataConnectors, "Price moves one way past positions")},
-          "hidden": true,
-          "type": "string"
-        },
         "elapsedTendTime": {
           "type": "number",
           "title": "Max time between tends",
@@ -463,7 +579,7 @@ export function triggerPropertyHelper(omit: TriggerStyle[] = []): string {
           "default": 1209600
         }
       },
-      "required": ["triggerWhenOver", "expectedDataTypes", "elapsedTendTime"]
+      "required": ["triggerWhenOver", "elapsedTendTime"]
     }
   }`;
 }

package/package.json

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