@steerprotocol/app-loader 2.1.1 → 3.0.0

package/lib/node.cjs

@@ -0,0 +1,607 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  Candle: () => Candle,
+  RawTradeData: () => RawTradeData,
+  loadWasm: () => loadWasm,
+  loadWasmSync: () => loadWasmSync
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/internal/instantiate.ts
+var import_ethers = require("ethers");
+
+// src/timestring.ts
+var DEFAULT_OPTS = {
+  hoursPerDay: 24,
+  daysPerWeek: 7,
+  weeksPerMonth: 4,
+  monthsPerYear: 12,
+  daysPerYear: 365.25
+};
+var UNIT_MAP = {
+  ms: ["ms", "milli", "millisecond", "milliseconds"],
+  s: ["s", "sec", "secs", "second", "seconds"],
+  m: ["m", "min", "mins", "minute", "minutes"],
+  h: ["h", "hr", "hrs", "hour", "hours"],
+  d: ["d", "day", "days"],
+  w: ["w", "week", "weeks"],
+  mth: ["mon", "mth", "mths", "month", "months"],
+  y: ["y", "yr", "yrs", "year", "years"]
+};
+function parseTimestring(value, returnUnit, opts) {
+  const options = Object.assign({}, DEFAULT_OPTS, opts || {});
+  let strValue;
+  if (typeof value === "number") {
+    strValue = parseInt(value.toString()) + "ms";
+  } else if (value.match(/^[-+]?[0-9.]+$/g)) {
+    strValue = parseInt(value) + "ms";
+  } else {
+    strValue = value;
+  }
+  let totalSeconds = 0;
+  const unitValues = getUnitValues(options);
+  const groups = strValue.toLowerCase().replace(/[^.\w+-]+/g, "").match(/[-+]?[0-9.]+[a-z]+/g);
+  if (groups === null) {
+    throw new Error(`The value [${strValue}] could not be parsed by timestring`);
+  }
+  groups.forEach((group) => {
+    const valMatch = group.match(/[0-9.]+/g);
+    const unitMatch = group.match(/[a-z]+/g);
+    if (valMatch && unitMatch) {
+      const val = parseFloat(valMatch[0]);
+      const unit = unitMatch[0];
+      totalSeconds += getSeconds(val, unit, unitValues);
+    }
+  });
+  if (returnUnit) {
+    return convert(totalSeconds, returnUnit, unitValues);
+  }
+  return totalSeconds;
+}
+function getUnitValues(opts) {
+  const unitValues = {
+    ms: 1e-3,
+    s: 1,
+    m: 60,
+    h: 3600,
+    d: 0,
+    w: 0,
+    mth: 0,
+    y: 0
+  };
+  unitValues.d = opts.hoursPerDay * unitValues.h;
+  unitValues.w = opts.daysPerWeek * unitValues.d;
+  unitValues.mth = opts.daysPerYear / opts.monthsPerYear * unitValues.d;
+  unitValues.y = opts.daysPerYear * unitValues.d;
+  return unitValues;
+}
+function getUnitKey(unit) {
+  for (const key of Object.keys(UNIT_MAP)) {
+    if (UNIT_MAP[key].indexOf(unit) > -1) {
+      return key;
+    }
+  }
+  throw new Error(`The unit [${unit}] is not supported by timestring`);
+}
+function getSeconds(value, unit, unitValues) {
+  return value * unitValues[getUnitKey(unit)];
+}
+function convert(value, unit, unitValues) {
+  return value / unitValues[getUnitKey(unit)];
+}
+
+// src/Candle.ts
+var Candle = class {
+  constructor(timestamp, high, low, open, close, volume) {
+    this.timestamp = timestamp;
+    this.high = high;
+    this.low = low;
+    this.open = open;
+    this.close = close;
+    this.volume = volume;
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+};
+function generateCandles(data, candleSize) {
+  const candleWidth = parseTimestring(candleSize, "ms", {});
+  if (data.length === 0) {
+    throw new Error("Input data is empty");
+  }
+  const _data = data.map((point) => {
+    return Object.assign(Object.assign({}, point), {
+      // This will convert the timestamp to milliseconds if it's in seconds
+      timestamp: point.timestamp && String(point.timestamp).length == 10 ? point.timestamp * 1e3 : point.timestamp
+    });
+  });
+  if (_data[0] === void 0 || Object.keys(_data[0]).length === 0) {
+    return [];
+  }
+  const ohlcvData = [];
+  let i = 0;
+  let currentTimestamp = Math.floor(_data[0].timestamp / candleWidth) * candleWidth;
+  let open = _data[0].price;
+  let high = _data[0].price;
+  let low = _data[0].price;
+  let close = _data[0].price;
+  let volume = 0;
+  while (i < _data.length) {
+    open = close;
+    high = close;
+    low = close;
+    volume = 0;
+    let innerI = i;
+    while (innerI < _data.length && _data[innerI].timestamp < currentTimestamp + candleWidth) {
+      open = innerI === 0 ? _data[innerI].price : open;
+      high = Math.max(high, _data[innerI].price);
+      low = Math.min(low, _data[innerI].price);
+      close = _data[innerI].price;
+      volume += _data[innerI].volume;
+      innerI++;
+    }
+    ohlcvData.push({
+      timestamp: currentTimestamp,
+      high,
+      low,
+      open,
+      close,
+      volume
+    });
+    currentTimestamp += candleWidth;
+    i = innerI;
+  }
+  return ohlcvData;
+}
+
+// src/RawTradeData.ts
+var RawTradeData = class {
+  constructor(timestamp, price, volume) {
+    this.timestamp = timestamp;
+    this.price = price;
+    this.volume = volume;
+  }
+};
+
+// src/internal/instantiate.ts
+function instantiate(module2, imports = {}, runtime = {}) {
+  let WASM_MEMORY;
+  let WASM_EXPORTS;
+  let WASM_DV;
+  let ASYNCIFY_PTR = 0;
+  let ASYNCIFY_MEM;
+  let ASYNCIFY_INITIALIZED = false;
+  let fetchFn = null;
+  let ccxtFn = null;
+  let detachedValue = null;
+  const adaptedImports = Object.assign(
+    {
+      console: {
+        log(text) {
+          console.log(__liftString(text));
+        }
+      },
+      ethers: {
+        keccak256_str(str_ptr) {
+          const str = __liftString(str_ptr);
+          const hash = import_ethers.ethers.keccak256(str);
+          return __lowerString(hash);
+        },
+        keccak256_buf(buf_ptr) {
+          const buf = __liftBuffer(buf_ptr);
+          const hash = import_ethers.ethers.keccak256(new Uint8Array(buf));
+          return __lowerString(hash);
+        }
+      },
+      // @ts-ignore
+      env: {
+        abort(message, fileName, lineNumber, columnNumber) {
+          (() => {
+            throw Error(`${__liftString(message)} in ${__liftString(fileName)}:${lineNumber}:${columnNumber}`);
+          })();
+        },
+        _initAsyncify(frame_ptr, stack_ptr) {
+          if (!WASM_EXPORTS["asyncify_get_state"])
+            throw new Error(
+              "Asyncify initialized, but not enabled when run! Compile with the --runPasses asyncify flag or asyncify-shim transform!"
+            );
+          if (ASYNCIFY_INITIALIZED) return;
+          ASYNCIFY_PTR = frame_ptr;
+          ASYNCIFY_MEM[ASYNCIFY_PTR >> 2] = ASYNCIFY_PTR + 8;
+          ASYNCIFY_MEM[ASYNCIFY_PTR + 4 >> 2] = stack_ptr;
+          ASYNCIFY_INITIALIZED = true;
+        },
+        generateCandles(data, candleSize) {
+          const _data = __liftString(data) || "[]";
+          const _candleSize = __liftString(candleSize) || "69m";
+          const candles = generateCandles(JSON.parse(_data), _candleSize);
+          return __lowerString(JSON.stringify(candles));
+        },
+        "console.log": (text) => {
+          console.log(__liftString(text));
+        },
+        ccxt_fetchOHLCV: (exchangeId, symbol, timeframe, limit, since) => {
+          const currentState = WASM_EXPORTS.asyncify_get_state();
+          if (currentState === 2 /* Rewinding */) {
+            WASM_EXPORTS.asyncify_stop_rewind();
+            const ptr = __lowerStaticArray(
+              (pointer, value) => {
+                __setU32(pointer, __lowerStaticArray(__setF64, 7, 3, value, Float64Array));
+              },
+              8,
+              2,
+              detachedValue
+            );
+            return ptr;
+          }
+          const _exchange = __liftString(exchangeId);
+          const _symbol = __liftString(symbol);
+          const _timeframe = __liftString(timeframe);
+          ccxtFn = async () => {
+            if (!_exchange || !_symbol || !_timeframe)
+              throw new Error("Exchange, Symbol, or Timeframe not provided when fetching OHCLV data.");
+            const ccxt = await getCcxtOrThrow(runtime);
+            const data = await new ccxt[_exchange]({
+              apiKey: "",
+              secret: ""
+            }).fetchOHLCV(_symbol, _timeframe, since, limit);
+            return data;
+          };
+          WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+        }
+      },
+      "as-fetch": {
+        _initAsyncify(frame_ptr, stack_ptr) {
+          if (!WASM_EXPORTS["asyncify_get_state"])
+            throw new Error(
+              "Asyncify initialized, but not enabled when run! Compile with the --runPasses asyncify flag or asyncify-shim transform!"
+            );
+          if (ASYNCIFY_INITIALIZED) return;
+          ASYNCIFY_PTR = frame_ptr;
+          ASYNCIFY_MEM[ASYNCIFY_PTR >> 2] = ASYNCIFY_PTR + 8;
+          ASYNCIFY_MEM[ASYNCIFY_PTR + 4 >> 2] = stack_ptr;
+          ASYNCIFY_INITIALIZED = true;
+        },
+        _fetchPOSTSync(url, mode, headers, body) {
+          const currentState = WASM_EXPORTS.asyncify_get_state();
+          if (currentState === 2 /* Rewinding */) {
+            WASM_EXPORTS.asyncify_stop_rewind();
+            const ptr = __lowerBuffer(detachedValue);
+            detachedValue = null;
+            return ptr;
+          }
+          fetchFn = async () => {
+            const fetchImpl = await getFetchOrThrow(runtime);
+            const res = await fetchImpl(__liftString(url) || "", {
+              method: "POST",
+              mode: modeToString(mode) || "cors",
+              headers: __liftArray(
+                (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                2,
+                headers
+              ) || [],
+              body: __liftBuffer(body)
+            });
+            const value = await res.arrayBuffer();
+            return value;
+          };
+          WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+        },
+        _fetchGETSync(url, mode, headers) {
+          const currentState = WASM_EXPORTS.asyncify_get_state();
+          if (currentState === 2 /* Rewinding */) {
+            WASM_EXPORTS.asyncify_stop_rewind();
+            const ptr = __lowerBuffer(detachedValue);
+            detachedValue = null;
+            return ptr;
+          }
+          fetchFn = 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 value = await res.arrayBuffer();
+            return value;
+          };
+          WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+        },
+        _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);
+          })();
+        },
+        _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);
+          })();
+        }
+      }
+    },
+    imports
+  );
+  const mod = new WebAssembly.Instance(module2, adaptedImports);
+  WASM_EXPORTS = mod.exports;
+  WASM_MEMORY = WASM_EXPORTS.memory || adaptedImports.env.memory;
+  ASYNCIFY_MEM = new Uint32Array(WASM_MEMORY.buffer);
+  const handledExports = Object.setPrototypeOf(
+    {
+      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);
+      },
+      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));
+          return true;
+        } catch (e) {
+          console.error(e);
+          return false;
+        }
+      },
+      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]);
+        }
+        let result;
+        try {
+          result = WASM_EXPORTS.execute(...loweredArgs);
+        } catch (error) {
+          if (params.length !== 0) {
+            throw error;
+          }
+          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 (fetchFn) fetchFn = null;
+        if (ccxtFn) ccxtFn = null;
+        return __liftString(result);
+      },
+      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());
+      },
+      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());
+      },
+      reset() {
+        if (WASM_EXPORTS["reset"]) WASM_EXPORTS.reset();
+      }
+    },
+    WASM_EXPORTS
+  );
+  WASM_DV = new DataView(WASM_MEMORY.buffer);
+  function __lower(val) {
+    if (typeof val === "number") {
+      return val;
+    } else if (typeof val === "string") {
+      return __lowerString(val);
+    } else if (val instanceof ArrayBuffer) {
+      return __lowerBuffer(val);
+    } else {
+      return 0;
+    }
+  }
+  function __liftString(ptr) {
+    if (!ptr) return null;
+    const end = ptr + new Uint32Array(WASM_MEMORY.buffer)[ptr - 4 >>> 2] >>> 1;
+    const memoryU16 = new Uint16Array(WASM_MEMORY.buffer);
+    let start = ptr >>> 1;
+    let string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  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 memoryU16 = new Uint16Array(WASM_MEMORY.buffer);
+    for (let i = 0; i < length; ++i) memoryU16[(ptr >>> 1) + i] = value.charCodeAt(i);
+    return ptr;
+  }
+  function __liftBuffer(ptr) {
+    if (!ptr) return null;
+    return WASM_MEMORY.buffer.slice(ptr, ptr + new Uint32Array(WASM_MEMORY.buffer)[ptr - 4 >>> 2]);
+  }
+  function __lowerBuffer(value) {
+    if (value == null) return 0;
+    const ptr = WASM_EXPORTS.__pin(WASM_EXPORTS.__new(value.byteLength, 1) >>> 0);
+    new Uint8Array(WASM_MEMORY.buffer).set(new Uint8Array(value), ptr);
+    return ptr;
+  }
+  function __liftArray(liftElement, align, ptr) {
+    if (!ptr) return null;
+    const dataStart = __getU32(ptr + 4);
+    const length = WASM_DV.getUint32(ptr + 12, true);
+    const values = new Array(length);
+    for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0));
+    return values;
+  }
+  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;
+    if (typedConstructor) {
+      new typedConstructor(WASM_MEMORY.buffer, buffer, length).set(values);
+    } else {
+      for (let i = 0; i < length; i++) lowerElement(buffer + (i << align >>> 0), values[i]);
+    }
+    return buffer;
+  }
+  function __setU32(ptr, value) {
+    try {
+      WASM_DV.setUint32(ptr, value, true);
+    } catch {
+      WASM_DV = new DataView(WASM_MEMORY.buffer);
+      WASM_DV.setUint32(ptr, value, true);
+    }
+  }
+  function __setF64(ptr, value) {
+    try {
+      WASM_DV.setFloat64(ptr, value, true);
+    } catch {
+      WASM_DV = new DataView(WASM_MEMORY.buffer);
+      WASM_DV.setFloat64(ptr, value, true);
+    }
+  }
+  function __getU32(ptr) {
+    try {
+      return WASM_DV.getUint32(ptr, true);
+    } catch {
+      WASM_DV = new DataView(WASM_MEMORY.buffer);
+      return WASM_DV.getUint32(ptr, true);
+    }
+  }
+  return handledExports;
+}
+async function getFetchOrThrow(runtime) {
+  if (!runtime.getFetch) {
+    throw new Error("Fetch is not available in this runtime.");
+  }
+  return runtime.getFetch();
+}
+async function getCcxtOrThrow(runtime) {
+  if (!runtime.getCcxt) {
+    throw new Error("ccxt is not available in this runtime.");
+  }
+  return runtime.getCcxt();
+}
+function modeToString(mode) {
+  if (mode == 1) return "cors";
+  if (mode == 2) return "no-cors";
+  if (mode == 3) return "same-origin";
+  if (mode == 4) return "navigate";
+  return null;
+}
+
+// src/node.ts
+function loadWasmSync(input, imports = {}) {
+  return instantiate(new WebAssembly.Module(input), imports, {
+    getFetch: getNodeFetch,
+    getCcxt
+  });
+}
+async function loadWasm(input, imports = {}) {
+  const module2 = typeof input === "string" ? await compileFromString(input) : await WebAssembly.compile(input);
+  return instantiate(module2, imports, {
+    getFetch: getNodeFetch,
+    getCcxt
+  });
+}
+async function compileFromString(input) {
+  if (isHttpUrl(input)) {
+    const fetchImpl = await getNodeFetch();
+    const response = await fetchImpl(input);
+    if (typeof WebAssembly.compileStreaming === "function") {
+      try {
+        return await WebAssembly.compileStreaming(Promise.resolve(response.clone()));
+      } catch {
+      }
+    }
+    return WebAssembly.compile(await response.arrayBuffer());
+  }
+  const fs = await import("fs/promises");
+  return WebAssembly.compile(await fs.readFile(input));
+}
+async function getNodeFetch() {
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  throw new Error("Fetch is not available in this Node runtime. Node 18+ is required.");
+}
+async function getCcxt() {
+  return (await import("ccxt")).default;
+}
+function isHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Candle,
+  RawTradeData,
+  loadWasm,
+  loadWasmSync
+});
+//# sourceMappingURL=node.cjs.map