@steerprotocol/app-loader 0.2.0 → 0.2.3

package/lib/index.d.ts

@@ -11,16 +11,6 @@ export type WasmModule = {
     responseHandler: typeof responseHandler;
     initialize: typeof initialize;
     execute: typeof execute;
-    "execute(param_1: string)": typeof execute;
-    "execute(param_1: string, param_2: string)": typeof execute;
-    "execute(param_1: string, param_2: string, param_3: string)": typeof execute;
-    "execute(param_1: string, param_2: string, param_3: string, param_4: string)": typeof execute;
-    "execute(param_1: string, param_2: string, param_3: string, param_4: string, param_5: string)": typeof execute;
-    "execute(param_1: string, param_2: string, param_3: string, param_4: string, param_5: string, param_6: string)": typeof execute;
-    "execute(param_1: string, param_2: string, param_3: string, param_4: string, param_5: string, param_6: string, param_7: string)": typeof execute;
-    "execute(param_1: string, param_2: string, param_3: string, param_4: string, param_5: string, param_6: string, param_7: string, param_8: string)": typeof execute;
-    "execute(param_1: string, param_2: string, param_3: string, param_4: string, param_5: string, param_6: string, param_7: string, param_8: string, param_9: string)": typeof execute;
-    "execute(param_1: string, param_2: string, param_3: string, param_4: string, param_5: string, param_6: string, param_7: string, param_8: string, param_9: string, param_10: string)": typeof execute;
     config: typeof config;
     version: typeof version;
     transform: typeof transform;

package/lib/index.js

@@ -45,14 +45,25 @@ const RawTradeData_1 = require("./RawTradeData");
 Object.defineProperty(exports, "RawTradeData", { enumerable: true, get: function () { return RawTradeData_1.RawTradeData; } });
 let _fetchGETSyncPtr = 0;
 let _fetchPOSTSyncPtr = 0;
+let _ohlcvPtr = 0;
 let ASYNCIFY_PTR = 0;
 let ASYNCIFY_MEM;
+let ASYNCIFY_INITIALIZED = false;
 let _exports;
 function instantiate(module, imports = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const adaptedImports = {
             // @ts-ignore
             env: Object.assign(Object.create(globalThis), imports.env || {}, {
+                _initAsyncify(frame_ptr, stack_ptr) {
+                    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;
+                },
                 abort(message, fileName, lineNumber, columnNumber) {
                     (() => {
                         throw Error(`${__liftString(message)} in ${__liftString(fileName)}:${lineNumber}:${columnNumber}`);
@@ -62,70 +73,64 @@ function instantiate(module, imports = {}) {
                     const _data = __liftString(data) || '[]';
                     const _candleSize = __liftString(candleSize) || '69m';
                     const candles = generateCandles(JSON.parse(_data), _candleSize);
-                    // We could pack this data into binary before sending...
-                    // Much faster
-                    // Which are 32 bit and which are 64?
-                    // I'll assume 32 bits for now though I believe timestamp should be 64
-                    /*
-                    const decodedCandles: Candle[] = [];
-                    
-                    for (let i = 0; i < __liftBuffer(data).byteLength >> 2; i++) {
-                      decodedCandles.push(decodeCandle(new Uint32Array(data, i * 6, 6)));
-                    }
-                    const candles =
-            
-                    let buffer = new Uint32Array(candles.length * 6);
-                    for (let i = 0; i < candles.length; i++) {
-                      const candle = candles[i];
-                      // Pack it into
-            
-                      // Structure: [timestamp, high, low, open, close, volume]
-                      // Stride: 24 bytes
-                      // This is essentially what FASS does
-            
-                      buffer.set(
-                        encodeCandle(candle),
-                        i
-                      );
-                    }
-                    return __lowerBuffer(buffer);*/
                     return __lowerString(JSON.stringify(candles));
                 },
                 'console.log': (text) => {
                     console.log(__liftString(text));
                 },
-                ccxt_fetchOHLCV: (exchangeId, symbol, timeframe, limit, since) => __awaiter(this, void 0, void 0, function* () {
-                    let ohlcv = '[]';
-                    const _exchangeId = __liftString(exchangeId >>> 0);
-                    const _symbol = __liftString(symbol >>> 0);
-                    const _timeframe = __liftString(timeframe >>> 0);
-                    const _since = since >>> 0;
-                    const _limit = limit >>> 0;
-                    if (_exchangeId &&
-                        _symbol &&
-                        _timeframe &&
-                        _since &&
-                        _limit) {
-                        try {
-                            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                ccxt_fetchOHLCV: (exchangeId, symbol, timeframe, limit, since) => {
+                    // Since may need to be passed as 64-bit?
+                    // Timestamps are large
+                    // @ts-ignore
+                    const currentState = _exports.asyncify_get_state();
+                    if (currentState === 2) {
+                        //console.log("asyncify_stop_rewind() [resume wasm]");
+                        // @ts-ignore
+                        _exports.asyncify_stop_rewind();
+                        return _ohlcvPtr;
+                    }
+                    else if (currentState === 0) {
+                        //console.log("asyncify_start_unwind() [pause wasm]");
+                        // @ts-ignore
+                        _exports.asyncify_start_unwind(ASYNCIFY_PTR);
+                        // How about we pass an Enum back and forth?
+                        const _exchange = __liftString(exchangeId);
+                        const _symbol = __liftString(symbol);
+                        const _timeframe = __liftString(timeframe);
+                        if (!_exchange || !_symbol || !_timeframe)
+                            throw new Error("Exchange, Symbol, or Timeframe not provided when fetching OHCLV data.");
+                        // @ts-ignore
+                        new ccxt_1.default[_exchange]({
+                            apiKey: "",
+                            secret: ""
+                        }).fetchOHLCV(_symbol, _timeframe, since, limit).then((data) => {
+                            //console.log("asyncify_stop_unwind() [unpause wasm]");
+                            // @ts-ignore
+                            _exports.asyncify_stop_unwind();
+                            // @ts-ignore: __new is defined
+                            _ohlcvPtr = __lowerStaticArray((pointer, value) => { __setU32(pointer, __lowerStaticArray(__setF64, 7, 3, value, Float64Array)); }, 8, 2, data);
+                            //console.log("asyncify_start_rewind() [resuming wasm]");
                             // @ts-ignore
-                            const data = yield new ccxt_1.default[_exchangeId]({}).fetchOHLCV(_symbol, _timeframe, _limit, _since);
-                            ccxt_1.default;
-                            ohlcv = JSON.stringify(data);
-                        }
-                        catch (e) {
-                            process.env.DEBUG && console.error(e);
-                        }
+                            _exports.asyncify_start_rewind(ASYNCIFY_PTR);
+                            _exports.execute();
+                        });
                     }
-                    return __lowerString(ohlcv);
-                })
+                }
             }),
+            console: {
+                log: (msg) => {
+                    console.log(__liftString(msg >>> 0));
+                }
+            },
             'as-fetch': {
                 _initAsyncify(frame_ptr, stack_ptr) {
+                    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) {
                     var _a;
@@ -254,6 +259,61 @@ function instantiate(module, imports = {}) {
                 }
             },
         }, exports);
+        let __dataview = new DataView(memory.buffer);
+        function __liftArray(liftElement, align, pointer) {
+            if (!pointer)
+                return null;
+            const dataStart = __getU32(pointer + 4), length = __dataview.getUint32(pointer + 12, true), values = new Array(length);
+            for (let i = 0; i < length; ++i)
+                values[i] = liftElement(dataStart + (i << align));
+            return values;
+        }
+        function __lowerArray(lowerElement, id, align, values) {
+            if (values == null)
+                return 0;
+            const length = values.length, 
+            // @ts-ignore
+            buffer = __retain(exports.__new(length << align, 1)), 
+            // @ts-ignore
+            header = __retain(exports.__new(16, id));
+            __setU32(header + 0, buffer);
+            __dataview.setUint32(header + 4, buffer, true);
+            __dataview.setUint32(header + 8, length << align, true);
+            __dataview.setUint32(header + 12, length, true);
+            for (let i = 0; i < length; ++i)
+                lowerElement(buffer + (i << align), values[i]);
+            // @ts-ignore
+            //exports.__unpin(buffer);
+            // @ts-ignore
+            //exports.__unpin(header);
+            return header;
+        }
+        function __lowerStaticArray(lowerElement, id, align, values, typedConstructor) {
+            if (values == null)
+                return 0;
+            const length = values.length, 
+            // @ts-ignore: __pin and __new are defined
+            buffer = _exports.__pin(_exports.__new(length << align, id)) >>> 0;
+            if (typedConstructor) {
+                new typedConstructor(_exports.memory.buffer, buffer, length).set(values);
+            }
+            else {
+                for (let i = 0; i < length; i++)
+                    lowerElement(buffer + (i << align >>> 0), values[i]);
+            }
+            // @ts-ignore: __unpin is defined
+            _exports.__unpin(buffer);
+            return buffer;
+        }
+        function __setF64(pointer, value) {
+            try {
+                __dataview.setFloat64(pointer, value, true);
+            }
+            catch (_a) {
+                __dataview = new DataView(memory.buffer);
+                __dataview.setFloat64(pointer, value, true);
+            }
+        }
         function __liftBuffer(pointer) {
             if (!pointer)
                 return null;
@@ -287,15 +347,6 @@ function instantiate(module, imports = {}) {
                 memoryU16[(pointer >>> 1) + i] = value.charCodeAt(i);
             return pointer;
         }
-        function __liftArray(liftElement, align, pointer) {
-            if (!pointer)
-                return null;
-            const dataStart = __getU32(pointer + 4), length = __dataview.getUint32(pointer + 12, true), values = new Array(length);
-            for (let i = 0; i < length; ++i)
-                values[i] = liftElement(dataStart + (i << align));
-            return values;
-        }
-        let __dataview = new DataView(memory.buffer);
         function __getU32(pointer) {
             try {
                 return __dataview.getUint32(pointer, true);
@@ -305,6 +356,39 @@ function instantiate(module, imports = {}) {
                 return __dataview.getUint32(pointer, true);
             }
         }
+        function __setU32(pointer, value) {
+            try {
+                __dataview.setUint32(pointer, value, true);
+            }
+            catch (_a) {
+                __dataview = new DataView(memory.buffer);
+                __dataview.setUint32(pointer, value, true);
+            }
+        }
+        const refcounts = new Map();
+        function __retain(pointer) {
+            if (pointer) {
+                const refcount = refcounts.get(pointer);
+                if (refcount)
+                    refcounts.set(pointer, refcount + 1);
+                // @ts-ignore: __pin is defined
+                else
+                    refcounts.set(exports.__pin(pointer), 1);
+            }
+            return pointer;
+        }
+        function __release(pointer) {
+            if (pointer) {
+                const refcount = refcounts.get(pointer);
+                // @ts-ignore: __unpin is defined
+                if (refcount === 1)
+                    exports.__unpin(pointer), refcounts.delete(pointer);
+                else if (refcount)
+                    refcounts.set(pointer, refcount - 1);
+                else
+                    throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`);
+            }
+        }
         function generateCandles(data, candleSize) {
             const candleWidth = (0, timestring_1.default)(candleSize, 'ms', {});
             if (data.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerprotocol/app-loader",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "App Loader for Steer Protocol",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -46,7 +46,7 @@
     "lib/**/*"
   ],
   "dependencies": {
-    "ccxt": "^3.0.30",
+    "ccxt": "^4.0.52",
     "timestring": "^7.0.0"
   }
 }