@steerprotocol/app-loader 1.1.0 → 1.1.1

package/lib/Candle.js

@@ -20,14 +20,7 @@ class Candle {
 }
 exports.Candle = Candle;
 function encodeCandle(candle) {
-    return new Uint32Array([
-        candle.timestamp,
-        candle.high,
-        candle.low,
-        candle.open,
-        candle.close,
-        candle.volume
-    ]);
+    return new Uint32Array([candle.timestamp, candle.high, candle.low, candle.open, candle.close, candle.volume]);
 }
 exports.encodeCandle = encodeCandle;
 function decodeCandle(buffer) {

package/lib/esm/Candle.d.ts

@@ -0,0 +1,14 @@
+import { RawTradeData } from './RawTradeData';
+export declare class Candle {
+    timestamp: number;
+    high: number;
+    low: number;
+    open: number;
+    close: number;
+    volume: number;
+    constructor(timestamp: number, high: number, low: number, open: number, close: number, volume: number);
+    toString(): string;
+}
+export declare function encodeCandle(candle: Candle): Uint32Array;
+export declare function decodeCandle(buffer: Uint32Array): Candle;
+export declare function generateCandles(data: RawTradeData[], candleSize: string): Candle[];

package/lib/esm/Candle.js

@@ -0,0 +1,75 @@
+import timestring from 'timestring';
+export class Candle {
+    timestamp;
+    high;
+    low;
+    open;
+    close;
+    volume;
+    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);
+    }
+}
+export function encodeCandle(candle) {
+    return new Uint32Array([candle.timestamp, candle.high, candle.low, candle.open, candle.close, candle.volume]);
+}
+export function decodeCandle(buffer) {
+    return new Candle(buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]);
+}
+export function generateCandles(data, candleSize) {
+    const candleWidth = timestring(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 * 1000 : point.timestamp,
+        });
+    });
+    if (_data[0] === undefined || 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.0;
+    while (i < _data.length) {
+        open = close;
+        high = close;
+        low = close;
+        volume = 0.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;
+}

package/lib/esm/RawTradeData.d.ts

@@ -0,0 +1,6 @@
+export declare class RawTradeData {
+    timestamp: number;
+    price: number;
+    volume: number;
+    constructor(timestamp: number, price: number, volume: number);
+}

package/lib/esm/RawTradeData.js

@@ -0,0 +1,10 @@
+export class RawTradeData {
+    timestamp;
+    price;
+    volume;
+    constructor(timestamp, price, volume) {
+        this.timestamp = timestamp;
+        this.price = price;
+        this.volume = volume;
+    }
+}

package/lib/esm/WasmModule.d.ts

@@ -0,0 +1,24 @@
+declare function responseHandler(body: ArrayBuffer, statusCode: number, redirected: number, callbackID: number): void;
+declare function initialize(config: string): void;
+declare function config(): string;
+declare function version(): number;
+declare function transform(): string;
+declare function execute(...params: number[] | string[] | ArrayBuffer[] | null[]): string;
+declare function __new(size: number, id: number): number;
+declare function __pin(ptr: number): number;
+declare function __unpin(ptr: number): number;
+declare function reset(): void;
+export type WasmModule = {
+    responseHandler: typeof responseHandler;
+    initialize: typeof initialize;
+    execute: typeof execute;
+    config: typeof config;
+    version: typeof version;
+    transform: typeof transform;
+    memory: WebAssembly.Memory;
+    __new: typeof __new;
+    __pin: typeof __pin;
+    __unpin: typeof __unpin;
+    reset: typeof reset;
+};
+export {};

package/lib/esm/WasmModule.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/index.d.ts

@@ -0,0 +1,18 @@
+import { Candle } from './Candle';
+import { RawTradeData } from './RawTradeData';
+import { WasmModule } from './WasmModule';
+export { Candle, RawTradeData, WasmModule };
+/**
+ * Load a wasm bundle synchronously. Only accepts the actual binary data.
+ * @param input - Wasm bundle data
+ * @param imports - Imports
+ * @returns
+ */
+export declare function loadWasmSync(input: ArrayBuffer, imports?: {}): WasmModule;
+/**
+ * Load a wasm bundle asynchronously. Accepts the actual binary data or file path.
+ * @param input - Wasm bundle data or path
+ * @param imports - Imports
+ * @returns
+ */
+export declare function loadWasm(input: string | ArrayBuffer, imports?: {}): Promise<WasmModule>;

package/lib/esm/index.js

@@ -0,0 +1,397 @@
+import { ethers } from 'ethers';
+import { Candle, generateCandles } from './Candle';
+import { RawTradeData } from './RawTradeData';
+let isNode = process || null;
+let fetchImpl = null;
+let fsImpl = null;
+let ccxt = null;
+if (globalThis['fetch'])
+    fetchImpl = fetch;
+export { Candle, RawTradeData };
+var State;
+(function (State) {
+    State[State["None"] = 0] = "None";
+    State[State["Unwinding"] = 1] = "Unwinding";
+    State[State["Rewinding"] = 2] = "Rewinding";
+})(State || (State = {}));
+/**
+ * Load a wasm bundle synchronously. Only accepts the actual binary data.
+ * @param input - Wasm bundle data
+ * @param imports - Imports
+ * @returns
+ */
+export function loadWasmSync(input, imports = {}) {
+    return instantiate(new WebAssembly.Module(input), imports);
+}
+/**
+ * Load a wasm bundle asynchronously. Accepts the actual binary data or file path.
+ * @param input - Wasm bundle data or path
+ * @param imports - Imports
+ * @returns
+ */
+export async function loadWasm(input, imports = {}) {
+    const mod = instantiate(await (async () => {
+        if (typeof input === 'string') {
+            if (isNode) {
+                if (!fetchImpl)
+                    fetchImpl = (await import('undici')).fetch;
+                if (!fsImpl)
+                    fsImpl = await import('fs/promises');
+                if (!ccxt)
+                    ccxt = (await import('ccxt')).default;
+                return WebAssembly.compile(await fsImpl.readFile(input));
+            }
+            return await WebAssembly.compileStreaming(globalThis.fetch(input));
+        }
+        else {
+            return WebAssembly.compile(input);
+        }
+    })(), imports);
+    return mod;
+}
+function instantiate(module, imports = {}) {
+    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 = ethers.keccak256(str);
+                return __lowerString(hash);
+            },
+            keccak256_buf(buf_ptr) {
+                const buf = __liftBuffer(buf_ptr);
+                const hash = 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) {
+                // @ts-ignore
+                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) => {
+                // @ts-ignore
+                const currentState = WASM_EXPORTS.asyncify_get_state();
+                if (currentState === State.Rewinding) {
+                    // @ts-ignore
+                    WASM_EXPORTS.asyncify_stop_rewind();
+                    // @ts-ignore
+                    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.');
+                    // @ts-ignore
+                    const data = await new ccxt[_exchange]({
+                        apiKey: '',
+                        secret: '',
+                    }).fetchOHLCV(_symbol, _timeframe, since, limit);
+                    return data;
+                };
+                // @ts-ignore
+                WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+            },
+        },
+        'as-fetch': {
+            _initAsyncify(frame_ptr, stack_ptr) {
+                // @ts-ignore
+                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;
+                // I don"t know if I need to reserve all this memory...
+                ASYNCIFY_MEM[(ASYNCIFY_PTR + 4) >> 2] = stack_ptr;
+                ASYNCIFY_INITIALIZED = true;
+            },
+            _fetchPOSTSync(url, mode, headers, body) {
+                // @ts-ignore
+                const currentState = WASM_EXPORTS.asyncify_get_state();
+                if (currentState === State.Rewinding) {
+                    // @ts-ignore
+                    WASM_EXPORTS.asyncify_stop_rewind();
+                    const ptr = __lowerBuffer(detachedValue);
+                    detachedValue = null;
+                    return ptr;
+                }
+                fetchFn = async () => {
+                    const res = await fetchImpl(__liftString(url) || '', {
+                        method: 'POST',
+                        mode: modeToString(mode) || 'cors',
+                        headers: __liftArray((pointer) => __liftArray((pointer) => __liftString(__getU32(pointer)), 2, __getU32(pointer)), 2, headers) || [],
+                        body: __liftBuffer(body),
+                    });
+                    const value = await res.arrayBuffer();
+                    return value;
+                };
+                // @ts-ignore
+                WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+            },
+            _fetchGETSync(url, mode, headers) {
+                // @ts-ignore
+                const currentState = WASM_EXPORTS.asyncify_get_state();
+                if (currentState === State.Rewinding) {
+                    // @ts-ignore
+                    WASM_EXPORTS.asyncify_stop_rewind();
+                    const ptr = __lowerBuffer(detachedValue);
+                    detachedValue = null;
+                    return ptr;
+                }
+                fetchFn = async () => {
+                    const res = await fetchImpl(__liftString(url) || '', {
+                        method: 'GET',
+                        mode: modeToString(mode) || 'cors',
+                        headers: __liftArray((pointer) => __liftArray((pointer) => __liftString(__getU32(pointer)), 2, __getU32(pointer)), 2, headers) || [],
+                    });
+                    const value = await res.arrayBuffer();
+                    return value;
+                };
+                // @ts-ignore
+                WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+            },
+            _fetchGET(url, mode, headers, callbackID) {
+                fetchImpl(__liftString(url) || '', {
+                    method: 'GET',
+                    mode: modeToString(mode) || 'cors',
+                    headers: __liftArray((pointer) => __liftArray((pointer) => __liftString(__getU32(pointer)), 2, __getU32(pointer)), 2, headers) || [],
+                }).then(async (res) => {
+                    const body = await res.arrayBuffer();
+                    WASM_EXPORTS.responseHandler(body, res.status, res.redirected ? 1 : 0, callbackID);
+                });
+            },
+            _fetchPOST(url, mode, headers, body, callbackID) {
+                fetchImpl(__liftString(url) || '', {
+                    method: 'POST',
+                    mode: modeToString(mode) || 'cors',
+                    body: body,
+                    headers: __liftArray((pointer) => __liftArray((pointer) => __liftString(__getU32(pointer)), 2, __getU32(pointer)), 2, headers) || [],
+                }).then(async (res) => {
+                    const body = await res.arrayBuffer();
+                    WASM_EXPORTS.responseHandler(body, res.status, res.redirected ? 1 : 0, callbackID);
+                });
+            },
+        },
+    }, imports);
+    const mod = new WebAssembly.Instance(module, adaptedImports);
+    WASM_EXPORTS = mod.exports;
+    // @ts-ignore
+    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.');
+            // @ts-ignore
+            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 {
+                // @ts-ignore
+                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 = WASM_EXPORTS.execute(...loweredArgs);
+            if (ASYNCIFY_INITIALIZED) {
+                // @ts-ignore
+                while (WASM_EXPORTS.asyncify_get_state() === State.Unwinding) {
+                    // @ts-ignore
+                    WASM_EXPORTS.asyncify_stop_unwind();
+                    if (fetchFn)
+                        detachedValue = await fetchFn();
+                    if (ccxtFn)
+                        detachedValue = await ccxtFn();
+                    // @ts-ignore
+                    WASM_EXPORTS.asyncify_start_rewind(ASYNCIFY_PTR);
+                    result = WASM_EXPORTS.execute();
+                }
+            }
+            if (fetchFn)
+                fetchFn = null;
+            if (ccxtFn)
+                ccxtFn = null;
+            // @ts-ignore
+            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;
+}
+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;
+}

package/lib/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/lib/index.d.ts

@@ -1,6 +1,6 @@
-import { Candle } from "./Candle";
-import { RawTradeData } from "./RawTradeData";
-import { WasmModule } from "./WasmModule";
+import { Candle } from './Candle';
+import { RawTradeData } from './RawTradeData';
+import { WasmModule } from './WasmModule';
 export { Candle, RawTradeData, WasmModule };
 /**
  * Load a wasm bundle synchronously. Only accepts the actual binary data.

package/lib/index.js

@@ -42,7 +42,7 @@ let isNode = process || null;
 let fetchImpl = null;
 let fsImpl = null;
 let ccxt = null;
-if (globalThis["fetch"])
+if (globalThis['fetch'])
     fetchImpl = fetch;
 var State;
 (function (State) {
@@ -69,14 +69,14 @@ exports.loadWasmSync = loadWasmSync;
 function loadWasm(input, imports = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const mod = instantiate(yield (() => __awaiter(this, void 0, void 0, function* () {
-            if (typeof input === "string") {
+            if (typeof input === 'string') {
                 if (isNode) {
                     if (!fetchImpl)
-                        fetchImpl = (yield Promise.resolve().then(() => __importStar(require("undici")))).fetch;
+                        fetchImpl = (yield Promise.resolve().then(() => __importStar(require('undici')))).fetch;
                     if (!fsImpl)
-                        fsImpl = yield Promise.resolve().then(() => __importStar(require("fs/promises")));
+                        fsImpl = yield Promise.resolve().then(() => __importStar(require('fs/promises')));
                     if (!ccxt)
-                        ccxt = (yield Promise.resolve().then(() => __importStar(require("ccxt")))).default;
+                        ccxt = (yield Promise.resolve().then(() => __importStar(require('ccxt')))).default;
                     return WebAssembly.compile(yield fsImpl.readFile(input));
                 }
                 return yield WebAssembly.compileStreaming(globalThis.fetch(input));
@@ -115,7 +115,7 @@ function instantiate(module, imports = {}) {
                 const buf = __liftBuffer(buf_ptr);
                 const hash = ethers_1.ethers.keccak256(new Uint8Array(buf));
                 return __lowerString(hash);
-            }
+            },
         },
         // @ts-ignore
         env: {
@@ -126,8 +126,8 @@ function instantiate(module, imports = {}) {
             },
             _initAsyncify(frame_ptr, stack_ptr) {
                 // @ts-ignore
-                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 (!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;
@@ -136,12 +136,12 @@ function instantiate(module, imports = {}) {
                 ASYNCIFY_INITIALIZED = true;
             },
             generateCandles(data, candleSize) {
-                const _data = __liftString(data) || "[]";
-                const _candleSize = __liftString(candleSize) || "69m";
+                const _data = __liftString(data) || '[]';
+                const _candleSize = __liftString(candleSize) || '69m';
                 const candles = (0, Candle_1.generateCandles)(JSON.parse(_data), _candleSize);
                 return __lowerString(JSON.stringify(candles));
             },
-            "console.log": (text) => {
+            'console.log': (text) => {
                 console.log(__liftString(text));
             },
             ccxt_fetchOHLCV: (exchangeId, symbol, timeframe, limit, since) => {
@@ -159,25 +159,25 @@ function instantiate(module, imports = {}) {
                 const _exchange = __liftString(exchangeId);
                 const _symbol = __liftString(symbol);
                 const _timeframe = __liftString(timeframe);
-                ccxtFn = (() => __awaiter(this, void 0, void 0, function* () {
+                ccxtFn = () => __awaiter(this, void 0, void 0, function* () {
                     if (!_exchange || !_symbol || !_timeframe)
-                        throw new Error("Exchange, Symbol, or Timeframe not provided when fetching OHCLV data.");
+                        throw new Error('Exchange, Symbol, or Timeframe not provided when fetching OHCLV data.');
                     // @ts-ignore
                     const data = yield new ccxt[_exchange]({
-                        apiKey: "",
-                        secret: "",
+                        apiKey: '',
+                        secret: '',
                     }).fetchOHLCV(_symbol, _timeframe, since, limit);
                     return data;
-                }));
+                });
                 // @ts-ignore
                 WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
-            }
+            },
         },
-        "as-fetch": {
+        'as-fetch': {
             _initAsyncify(frame_ptr, stack_ptr) {
                 // @ts-ignore
-                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 (!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;
@@ -196,16 +196,16 @@ function instantiate(module, imports = {}) {
                     detachedValue = null;
                     return ptr;
                 }
-                fetchFn = (() => __awaiter(this, void 0, void 0, function* () {
-                    const res = yield fetchImpl(__liftString(url) || "", {
-                        method: "POST",
-                        mode: modeToString(mode) || "cors",
+                fetchFn = () => __awaiter(this, void 0, void 0, function* () {
+                    const res = yield fetchImpl(__liftString(url) || '', {
+                        method: 'POST',
+                        mode: modeToString(mode) || 'cors',
                         headers: __liftArray((pointer) => __liftArray((pointer) => __liftString(__getU32(pointer)), 2, __getU32(pointer)), 2, headers) || [],
-                        body: __liftBuffer(body)
+                        body: __liftBuffer(body),
                     });
                     const value = yield res.arrayBuffer();
                     return value;
-                }));
+                });
                 // @ts-ignore
                 WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
             },
@@ -219,22 +219,22 @@ function instantiate(module, imports = {}) {
                     detachedValue = null;
                     return ptr;
                 }
-                fetchFn = (() => __awaiter(this, void 0, void 0, function* () {
-                    const res = yield fetchImpl(__liftString(url) || "", {
-                        method: "GET",
-                        mode: modeToString(mode) || "cors",
+                fetchFn = () => __awaiter(this, void 0, void 0, function* () {
+                    const res = yield fetchImpl(__liftString(url) || '', {
+                        method: 'GET',
+                        mode: modeToString(mode) || 'cors',
                         headers: __liftArray((pointer) => __liftArray((pointer) => __liftString(__getU32(pointer)), 2, __getU32(pointer)), 2, headers) || [],
                     });
                     const value = yield res.arrayBuffer();
                     return value;
-                }));
+                });
                 // @ts-ignore
                 WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
             },
             _fetchGET(url, mode, headers, callbackID) {
-                fetchImpl(__liftString(url) || "", {
-                    method: "GET",
-                    mode: modeToString(mode) || "cors",
+                fetchImpl(__liftString(url) || '', {
+                    method: 'GET',
+                    mode: modeToString(mode) || 'cors',
                     headers: __liftArray((pointer) => __liftArray((pointer) => __liftString(__getU32(pointer)), 2, __getU32(pointer)), 2, headers) || [],
                 }).then((res) => __awaiter(this, void 0, void 0, function* () {
                     const body = yield res.arrayBuffer();
@@ -242,9 +242,9 @@ function instantiate(module, imports = {}) {
                 }));
             },
             _fetchPOST(url, mode, headers, body, callbackID) {
-                fetchImpl(__liftString(url) || "", {
-                    method: "POST",
-                    mode: modeToString(mode) || "cors",
+                fetchImpl(__liftString(url) || '', {
+                    method: 'POST',
+                    mode: modeToString(mode) || 'cors',
                     body: body,
                     headers: __liftArray((pointer) => __liftArray((pointer) => __liftString(__getU32(pointer)), 2, __getU32(pointer)), 2, headers) || [],
                 }).then((res) => __awaiter(this, void 0, void 0, function* () {
@@ -261,14 +261,14 @@ function instantiate(module, imports = {}) {
     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.");
+            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.');
             // @ts-ignore
             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?");
+            if (!WASM_EXPORTS['initialize'])
+                throw new Error('Unable to call .initialize on wasm module. Are you sure this is a data connector?');
             try {
                 // @ts-ignore
                 WASM_EXPORTS.initialize(__lowerString(config));
@@ -281,8 +281,8 @@ function instantiate(module, imports = {}) {
         },
         execute(...params) {
             return __awaiter(this, void 0, void 0, function* () {
-                if (!WASM_EXPORTS["execute"])
-                    throw new Error("Unable to call .execute on wasm module. Are you sure this is a data connector?");
+                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]);
@@ -311,26 +311,26 @@ function instantiate(module, imports = {}) {
             });
         },
         config() {
-            if (!WASM_EXPORTS["config"])
-                throw new Error("Unable to call .config on wasm module. Are you sure this is a data connector?");
+            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?");
+            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"])
+            if (WASM_EXPORTS['reset'])
                 WASM_EXPORTS.reset();
-        }
+        },
     }, WASM_EXPORTS);
     WASM_DV = new DataView(WASM_MEMORY.buffer);
     function __lower(val) {
-        if (typeof val === "number") {
+        if (typeof val === 'number') {
             return val;
         }
-        else if (typeof val === "string") {
+        else if (typeof val === 'string') {
             return __lowerString(val);
         }
         else if (val instanceof ArrayBuffer) {
@@ -343,12 +343,12 @@ function instantiate(module, imports = {}) {
     function __liftString(ptr) {
         if (!ptr)
             return null;
-        const end = ptr + new Uint32Array(WASM_MEMORY.buffer)[ptr - 4 >>> 2] >>> 1;
+        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 = "";
+        let string = '';
         while (end - start > 1024)
-            string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+            string += String.fromCharCode(...memoryU16.subarray(start, (start += 1024)));
         return string + String.fromCharCode(...memoryU16.subarray(start, end));
     }
     function __lowerString(value) {
@@ -364,7 +364,7 @@ function instantiate(module, imports = {}) {
     function __liftBuffer(ptr) {
         if (!ptr)
             return null;
-        return WASM_MEMORY.buffer.slice(ptr, ptr + new Uint32Array(WASM_MEMORY.buffer)[ptr - 4 >>> 2]);
+        return WASM_MEMORY.buffer.slice(ptr, ptr + new Uint32Array(WASM_MEMORY.buffer)[(ptr - 4) >>> 2]);
     }
     function __lowerBuffer(value) {
         if (value == null)
@@ -380,7 +380,7 @@ function instantiate(module, imports = {}) {
         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));
+            values[i] = liftElement(dataStart + ((i << align) >>> 0));
         return values;
     }
     function __lowerStaticArray(lowerElement, id, align, values, typedConstructor = null) {
@@ -393,7 +393,7 @@ function instantiate(module, imports = {}) {
         }
         else {
             for (let i = 0; i < length; i++)
-                lowerElement(buffer + (i << align >>> 0), values[i]);
+                lowerElement(buffer + ((i << align) >>> 0), values[i]);
         }
         return buffer;
     }
@@ -428,12 +428,12 @@ function instantiate(module, imports = {}) {
 }
 function modeToString(mode) {
     if (mode == 1)
-        return "cors";
+        return 'cors';
     if (mode == 2)
-        return "no-cors";
+        return 'no-cors';
     if (mode == 3)
-        return "same-origin";
+        return 'same-origin';
     if (mode == 4)
-        return "navigate";
+        return 'navigate';
     return null;
 }

package/package.json

@@ -1,11 +1,26 @@
 {
   "name": "@steerprotocol/app-loader",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "App Loader for Steer Protocol",
   "main": "lib/index.js",
+  "module": "lib/esm/index.js",
   "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/index.js"
+    },
+    "./*": "./lib/*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf lib && npm run build:cjs && npm run build:esm && npm run build:post",
+    "build:cjs": "tsc",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:post": "echo '{\"type\": \"module\"}' > lib/esm/package.json",
     "format": "prettier --write \"src/**/*.(js|ts)\"",
     "lint": "eslint src --ext .js,.ts",
     "lint:fix": "eslint src --fix --ext .js,.ts",
@@ -18,7 +33,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/hebertcisco/ts-npm-package-boilerplate.git"
+    "url": "git+https://github.com/SteerProtocol/app-loader.git"
   },
   "keywords": [
     "boilerplate",
@@ -26,11 +41,20 @@
   ],
   "author": "Hebert Cisco",
   "license": "MIT",
+  "release": {
+    "branches": [
+      "main"
+    ]
+  },
   "bugs": {
-    "url": "https://github.com/hebertcisco/ts-npm-package-boilerplate/issues"
+    "url": "https://github.com/SteerProtocol/app-loader/issues"
   },
-  "homepage": "https://github.com/hebertcisco/ts-npm-package-boilerplate#readme",
+  "homepage": "https://github.com/SteerProtocol/app-loader#readme",
   "devDependencies": {
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.3",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/jest": "29.5.6",
     "@types/timestring": "^6.0.4",
     "@typescript-eslint/eslint-plugin": "6.8.0",
@@ -39,6 +63,7 @@
     "eslint-plugin-jest": "27.4.2",
     "jest": "29.7.0",
     "prettier": "3.0.3",
+    "semantic-release": "^24.2.9",
     "ts-jest": "29.1.1",
     "typescript": "5.2.2"
   },