@steerprotocol/app-loader 3.0.0 → 3.0.1

package/lib/node.mjs

@@ -83,6 +83,15 @@ function convert(value, unit, unitValues) {
 
 // src/Candle.ts
 var Candle = class {
+  /**
+   * Creates a candle instance.
+   * @param timestamp - Candle open timestamp in milliseconds.
+   * @param high - Highest traded price.
+   * @param low - Lowest traded price.
+   * @param open - Opening price.
+   * @param close - Closing price.
+   * @param volume - Total traded volume.
+   */
   constructor(timestamp, high, low, open, close, volume) {
     this.timestamp = timestamp;
     this.high = high;
@@ -91,6 +100,10 @@ var Candle = class {
     this.close = close;
     this.volume = volume;
   }
+  /**
+   * Serializes the candle as JSON.
+   * @returns The candle as a JSON string.
+   */
   toString() {
     return JSON.stringify(this);
   }
@@ -102,7 +115,7 @@ function generateCandles(data, candleSize) {
   }
   const _data = data.map((point) => {
     return Object.assign(Object.assign({}, point), {
-      // This will convert the timestamp to milliseconds if it's in seconds
+      // Older inputs may still provide 10-digit second timestamps instead of milliseconds.
       timestamp: point.timestamp && String(point.timestamp).length == 10 ? point.timestamp * 1e3 : point.timestamp
     });
   });
@@ -147,6 +160,12 @@ function generateCandles(data, candleSize) {
 
 // src/RawTradeData.ts
 var RawTradeData = class {
+  /**
+   * Creates a raw trade data point.
+   * @param timestamp - Trade timestamp.
+   * @param price - Trade price.
+   * @param volume - Trade volume.
+   */
   constructor(timestamp, price, volume) {
     this.timestamp = timestamp;
     this.price = price;
@@ -165,32 +184,60 @@ function instantiate(module, imports = {}, runtime = {}) {
   let fetchFn = null;
   let ccxtFn = null;
   let detachedValue = null;
+  let executeInFlight = false;
+  const pinScopes = [];
   const adaptedImports = Object.assign(
     {
       console: {
+        /**
+         * Logs a lifted AssemblyScript string.
+         * @param text - Pointer to the message string.
+         */
         log(text) {
           console.log(__liftString(text));
         }
       },
       ethers: {
+        /**
+         * Hashes a lifted string with `keccak256`.
+         * @param str_ptr - Pointer to the input string.
+         * @returns Pointer to the hashed string result.
+         */
         keccak256_str(str_ptr) {
           const str = __liftString(str_ptr);
           const hash = ethers.keccak256(str);
-          return __lowerString(hash);
+          return withAutoPinScope(() => __lowerString(hash));
         },
+        /**
+         * Hashes a lifted buffer with `keccak256`.
+         * @param buf_ptr - Pointer to the input buffer.
+         * @returns Pointer to the hashed string result.
+         */
         keccak256_buf(buf_ptr) {
           const buf = __liftBuffer(buf_ptr);
           const hash = ethers.keccak256(new Uint8Array(buf));
-          return __lowerString(hash);
+          return withAutoPinScope(() => __lowerString(hash));
         }
       },
       // @ts-ignore
       env: {
+        /**
+         * Raises a JavaScript error for an AssemblyScript abort.
+         * @param message - Pointer to the abort message.
+         * @param fileName - Pointer to the source filename.
+         * @param lineNumber - Source line number.
+         * @param columnNumber - Source column number.
+         */
         abort(message, fileName, lineNumber, columnNumber) {
           (() => {
             throw Error(`${__liftString(message)} in ${__liftString(fileName)}:${lineNumber}:${columnNumber}`);
           })();
         },
+        /**
+         * Initializes Asyncify bookkeeping for host callbacks.
+         * @param frame_ptr - Asyncify frame pointer.
+         * @param stack_ptr - Asyncify stack pointer.
+         */
         _initAsyncify(frame_ptr, stack_ptr) {
           if (!WASM_EXPORTS["asyncify_get_state"])
             throw new Error(
@@ -202,15 +249,34 @@ function instantiate(module, imports = {}, runtime = {}) {
           ASYNCIFY_MEM[ASYNCIFY_PTR + 4 >> 2] = stack_ptr;
           ASYNCIFY_INITIALIZED = true;
         },
+        /**
+         * Aggregates lifted trade data into candles.
+         * @param data - Pointer to the serialized trade array.
+         * @param candleSize - Pointer to the candle size string.
+         * @returns Pointer to the serialized candle array.
+         */
         generateCandles(data, candleSize) {
           const _data = __liftString(data) || "[]";
           const _candleSize = __liftString(candleSize) || "69m";
           const candles = generateCandles(JSON.parse(_data), _candleSize);
-          return __lowerString(JSON.stringify(candles));
+          return withAutoPinScope(() => __lowerString(JSON.stringify(candles)));
         },
+        /**
+         * Logs a lifted AssemblyScript string.
+         * @param text - Pointer to the message string.
+         */
         "console.log": (text) => {
           console.log(__liftString(text));
         },
+        /**
+         * Schedules an async OHLCV request for asyncified execution.
+         * @param exchangeId - Pointer to the exchange id string.
+         * @param symbol - Pointer to the market symbol string.
+         * @param timeframe - Pointer to the timeframe string.
+         * @param limit - Maximum number of rows.
+         * @param since - Optional start timestamp.
+         * @returns Pointer to the rewound OHLCV matrix when replaying.
+         */
         ccxt_fetchOHLCV: (exchangeId, symbol, timeframe, limit, since) => {
           const currentState = WASM_EXPORTS.asyncify_get_state();
           if (currentState === 2 /* Rewinding */) {
@@ -242,6 +308,11 @@ function instantiate(module, imports = {}, runtime = {}) {
         }
       },
       "as-fetch": {
+        /**
+         * Initializes Asyncify bookkeeping for as-fetch host calls.
+         * @param frame_ptr - Asyncify frame pointer.
+         * @param stack_ptr - Asyncify stack pointer.
+         */
         _initAsyncify(frame_ptr, stack_ptr) {
           if (!WASM_EXPORTS["asyncify_get_state"])
             throw new Error(
@@ -253,6 +324,14 @@ function instantiate(module, imports = {}, runtime = {}) {
           ASYNCIFY_MEM[ASYNCIFY_PTR + 4 >> 2] = stack_ptr;
           ASYNCIFY_INITIALIZED = true;
         },
+        /**
+         * Executes a synchronous asyncified POST request.
+         * @param url - Pointer to the request URL.
+         * @param mode - Numeric fetch mode.
+         * @param headers - Pointer to the header array.
+         * @param body - Pointer to the request body.
+         * @returns Pointer to the response body when replaying.
+         */
         _fetchPOSTSync(url, mode, headers, body) {
           const currentState = WASM_EXPORTS.asyncify_get_state();
           if (currentState === 2 /* Rewinding */) {
@@ -278,6 +357,13 @@ function instantiate(module, imports = {}, runtime = {}) {
           };
           WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
         },
+        /**
+         * Executes a synchronous asyncified GET request.
+         * @param url - Pointer to the request URL.
+         * @param mode - Numeric fetch mode.
+         * @param headers - Pointer to the header array.
+         * @returns Pointer to the response body when replaying.
+         */
         _fetchGETSync(url, mode, headers) {
           const currentState = WASM_EXPORTS.asyncify_get_state();
           if (currentState === 2 /* Rewinding */) {
@@ -302,37 +388,60 @@ function instantiate(module, imports = {}, runtime = {}) {
           };
           WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
         },
+        /**
+         * Executes an asynchronous GET request and forwards the response to wasm.
+         * @param url - Pointer to the request URL.
+         * @param mode - Numeric fetch mode.
+         * @param headers - Pointer to the header array.
+         * @param callbackID - Wasm callback identifier.
+         */
         _fetchGET(url, mode, headers, callbackID) {
           void (async () => {
-            const fetchImpl = await getFetchOrThrow(runtime);
-            const res = await fetchImpl(__liftString(url) || "", {
-              method: "GET",
-              mode: modeToString(mode) || "cors",
-              headers: __liftArray(
-                (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
-                2,
-                headers
-              ) || []
-            });
-            const body = await res.arrayBuffer();
-            WASM_EXPORTS.responseHandler(body, res.status, res.redirected ? 1 : 0, callbackID);
+            try {
+              const fetchImpl = await getFetchOrThrow(runtime);
+              const res = await fetchImpl(__liftString(url) || "", {
+                method: "GET",
+                mode: modeToString(mode) || "cors",
+                headers: __liftArray(
+                  (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                  2,
+                  headers
+                ) || []
+              });
+              const body = await res.arrayBuffer();
+              WASM_EXPORTS.responseHandler(body, res.status, res.redirected ? 1 : 0, callbackID);
+            } catch (error) {
+              console.error(error);
+            }
           })();
         },
+        /**
+         * Executes an asynchronous POST request and forwards the response to wasm.
+         * @param url - Pointer to the request URL.
+         * @param mode - Numeric fetch mode.
+         * @param headers - Pointer to the header array.
+         * @param body - Request body.
+         * @param callbackID - Wasm callback identifier.
+         */
         _fetchPOST(url, mode, headers, body, callbackID) {
           void (async () => {
-            const fetchImpl = await getFetchOrThrow(runtime);
-            const res = await fetchImpl(__liftString(url) || "", {
-              method: "POST",
-              mode: modeToString(mode) || "cors",
-              body,
-              headers: __liftArray(
-                (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
-                2,
-                headers
-              ) || []
-            });
-            const responseBody = await res.arrayBuffer();
-            WASM_EXPORTS.responseHandler(responseBody, res.status, res.redirected ? 1 : 0, callbackID);
+            try {
+              const fetchImpl = await getFetchOrThrow(runtime);
+              const res = await fetchImpl(__liftString(url) || "", {
+                method: "POST",
+                mode: modeToString(mode) || "cors",
+                body,
+                headers: __liftArray(
+                  (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                  2,
+                  headers
+                ) || []
+              });
+              const responseBody = await res.arrayBuffer();
+              WASM_EXPORTS.responseHandler(responseBody, res.status, res.redirected ? 1 : 0, callbackID);
+            } catch (error) {
+              console.error(error);
+            }
           })();
         }
       }
@@ -345,63 +454,110 @@ function instantiate(module, imports = {}, runtime = {}) {
   ASYNCIFY_MEM = new Uint32Array(WASM_MEMORY.buffer);
   const handledExports = Object.setPrototypeOf(
     {
+      /**
+       * Forwards an HTTP response body into the wasm export.
+       * @param body - Response body.
+       * @param statusCode - HTTP status code.
+       * @param redirected - Whether the request redirected.
+       * @param callbackID - Wasm callback identifier.
+       */
       responseHandler(body, statusCode, redirected, callbackID) {
         if (!WASM_EXPORTS["responseHandler"])
           throw new Error(
             'Unable to call .responseHandler on wasm module. Add the line export { responseHandler } from "as-fetch/assembly" to your entry file.'
           );
-        WASM_EXPORTS.responseHandler(__lowerBuffer(body), statusCode, redirected ? 1 : 0, callbackID);
+        withPinScope(() => {
+          WASM_EXPORTS.responseHandler(__lowerBuffer(body), statusCode, redirected ? 1 : 0, callbackID);
+        });
       },
+      /**
+       * Initializes the wasm module with a JSON configuration payload.
+       * @param config - Serialized connector configuration.
+       * @returns `true` when initialization succeeds.
+       */
       initialize(config) {
         if (!WASM_EXPORTS["initialize"])
           throw new Error("Unable to call .initialize on wasm module. Are you sure this is a data connector?");
         try {
-          WASM_EXPORTS.initialize(__lowerString(config));
+          withPinScope(() => {
+            WASM_EXPORTS.initialize(__lowerString(config));
+          });
           return true;
         } catch (e) {
           console.error(e);
           return false;
         }
       },
+      /**
+       * Executes the wasm module, replaying arguments across asyncify rewinds.
+       * @param params - Logical execute arguments.
+       * @returns The lifted execute result.
+       */
       async execute(...params) {
         if (!WASM_EXPORTS["execute"])
           throw new Error("Unable to call .execute on wasm module. Are you sure this is a data connector?");
-        const loweredArgs = new Array(params.length);
-        for (let i = 0; i < params.length; i++) {
-          loweredArgs[i] = __lower(params[i]);
+        if (executeInFlight) {
+          throw new Error("Concurrent execute calls are not supported on the same wasm instance.");
         }
-        let result;
+        executeInFlight = true;
+        const replayArgs = snapshotLogicalArgs(params);
         try {
-          result = WASM_EXPORTS.execute(...loweredArgs);
-        } catch (error) {
-          if (params.length !== 0) {
-            throw error;
+          let result;
+          try {
+            result = executeWithReplayArgs(replayArgs);
+          } catch (error) {
+            if (params.length !== 0) {
+              throw error;
+            }
+            replayArgs.splice(0, replayArgs.length, "");
+            result = executeWithReplayArgs(replayArgs);
           }
-          result = WASM_EXPORTS.execute(__lowerString(""));
-        }
-        if (ASYNCIFY_INITIALIZED) {
-          while (WASM_EXPORTS.asyncify_get_state() === 1 /* Unwinding */) {
-            WASM_EXPORTS.asyncify_stop_unwind();
-            if (fetchFn) detachedValue = await fetchFn();
-            if (ccxtFn) detachedValue = await ccxtFn();
-            WASM_EXPORTS.asyncify_start_rewind(ASYNCIFY_PTR);
-            result = WASM_EXPORTS.execute();
+          if (ASYNCIFY_INITIALIZED) {
+            while (WASM_EXPORTS.asyncify_get_state() === 1 /* Unwinding */) {
+              WASM_EXPORTS.asyncify_stop_unwind();
+              if (fetchFn) {
+                const pendingFetch = fetchFn;
+                fetchFn = null;
+                detachedValue = await pendingFetch();
+              }
+              if (ccxtFn) {
+                const pendingCcxt = ccxtFn;
+                ccxtFn = null;
+                detachedValue = await pendingCcxt();
+              }
+              WASM_EXPORTS.asyncify_start_rewind(ASYNCIFY_PTR);
+              result = executeWithReplayArgs(replayArgs);
+            }
           }
+          return __liftString(result);
+        } finally {
+          fetchFn = null;
+          ccxtFn = null;
+          detachedValue = null;
+          executeInFlight = false;
         }
-        if (fetchFn) fetchFn = null;
-        if (ccxtFn) ccxtFn = null;
-        return __liftString(result);
       },
+      /**
+       * Reads the connector configuration schema from wasm.
+       * @returns The lifted configuration payload.
+       */
       config() {
         if (!WASM_EXPORTS["config"])
           throw new Error("Unable to call .config on wasm module. Are you sure this is a data connector?");
-        return __liftString(WASM_EXPORTS.config());
+        return withPinScope(() => __liftString(WASM_EXPORTS.config()));
       },
+      /**
+       * Reads the connector transform from wasm.
+       * @returns The lifted transform payload.
+       */
       transform() {
         if (!WASM_EXPORTS["transform"])
           throw new Error("Unable to call .transform on wasm module. Are you sure this is a data connector?");
-        return __liftString(WASM_EXPORTS.transform());
+        return withPinScope(() => __liftString(WASM_EXPORTS.transform()));
       },
+      /**
+       * Resets wasm module state when supported.
+       */
       reset() {
         if (WASM_EXPORTS["reset"]) WASM_EXPORTS.reset();
       }
@@ -420,6 +576,48 @@ function instantiate(module, imports = {}, runtime = {}) {
       return 0;
     }
   }
+  function lowerArgs(values) {
+    const loweredArgs = new Array(values.length);
+    for (let i = 0; i < values.length; i++) {
+      loweredArgs[i] = __lower(values[i]);
+    }
+    return loweredArgs;
+  }
+  function snapshotLogicalArgs(values) {
+    return values.map((value) => {
+      if (value instanceof ArrayBuffer) {
+        return value.slice(0);
+      }
+      return value;
+    });
+  }
+  function executeWithReplayArgs(values) {
+    return withPinScope(() => WASM_EXPORTS.execute(...lowerArgs(values)));
+  }
+  function withPinScope(fn) {
+    pinScopes.push([]);
+    try {
+      return fn();
+    } finally {
+      const scope = pinScopes.pop() || [];
+      for (let i = scope.length - 1; i >= 0; i--) {
+        WASM_EXPORTS.__unpin(scope[i]);
+      }
+    }
+  }
+  function withAutoPinScope(fn) {
+    if (pinScopes.length > 0) {
+      return fn();
+    }
+    return withPinScope(fn);
+  }
+  function trackPinnedPointer(ptr) {
+    const scope = pinScopes[pinScopes.length - 1];
+    if (scope) {
+      scope.push(ptr);
+    }
+    return ptr;
+  }
   function __liftString(ptr) {
     if (!ptr) return null;
     const end = ptr + new Uint32Array(WASM_MEMORY.buffer)[ptr - 4 >>> 2] >>> 1;
@@ -432,7 +630,7 @@ function instantiate(module, imports = {}, runtime = {}) {
   function __lowerString(value) {
     if (value == null) return 0;
     const length = value.length;
-    const ptr = WASM_EXPORTS.__pin(WASM_EXPORTS.__new(length << 1, 2) >>> 0);
+    const ptr = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(length << 1, 2) >>> 0));
     const memoryU16 = new Uint16Array(WASM_MEMORY.buffer);
     for (let i = 0; i < length; ++i) memoryU16[(ptr >>> 1) + i] = value.charCodeAt(i);
     return ptr;
@@ -443,7 +641,7 @@ function instantiate(module, imports = {}, runtime = {}) {
   }
   function __lowerBuffer(value) {
     if (value == null) return 0;
-    const ptr = WASM_EXPORTS.__pin(WASM_EXPORTS.__new(value.byteLength, 1) >>> 0);
+    const ptr = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(value.byteLength, 1) >>> 0));
     new Uint8Array(WASM_MEMORY.buffer).set(new Uint8Array(value), ptr);
     return ptr;
   }
@@ -458,7 +656,7 @@ function instantiate(module, imports = {}, runtime = {}) {
   function __lowerStaticArray(lowerElement, id, align, values, typedConstructor = null) {
     if (values == null) return 0;
     const length = values.length;
-    const buffer = WASM_EXPORTS.__pin(WASM_EXPORTS.__new(length << align, id)) >>> 0;
+    const buffer = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(length << align, id)) >>> 0) >>> 0;
     if (typedConstructor) {
       new typedConstructor(WASM_MEMORY.buffer, buffer, length).set(values);
     } else {