@steerprotocol/data-connector-loader 0.0.1

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2022 Hebert Cisco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# Steer Protocol App Loader

package/lib/dataConnector.d.ts

@@ -0,0 +1,20 @@
+import { WasmModule } from '@steerprotocol/app-loader';
+import { ExecutionContext } from './types';
+export declare class DataConnector {
+    private wasmFile;
+    module?: WasmModule;
+    config: string;
+    configObj: {
+        [key: string]: string;
+    };
+    executionContext?: ExecutionContext & {
+        epochTimestamp: number;
+    };
+    constructor(wasmFile: string | ArrayBuffer, _config: string);
+    load(): Promise<WasmModule>;
+    setExecutionContext(executionContext: ExecutionContext): void;
+    execute(response: string): Promise<string>;
+    getResults(): string;
+    version(): number;
+    private subtractDate;
+}

package/lib/dataConnector.js

@@ -0,0 +1,86 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataConnector = void 0;
+const app_loader_1 = require("@steerprotocol/app-loader");
+class DataConnector {
+    constructor(wasmFile, _config) {
+        this.wasmFile = wasmFile;
+        this.config = _config;
+        this.configObj = JSON.parse(_config);
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = yield (0, app_loader_1.loadWasm)(this.wasmFile, {});
+            this.module = instance;
+            this.module.initialize(this.config);
+            return this.module;
+        });
+    }
+    setExecutionContext(executionContext) {
+        var _a;
+        // Determine the timestamp for epoch
+        const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
+        // Divide milliseconds data to seconds for transformation bundle
+        const timestampInSecs = Math.floor(timestamp / 1000);
+        this.executionContext = Object.assign(Object.assign({}, executionContext), { epochTimestamp: timestampInSecs });
+        (_a = this.module) === null || _a === void 0 ? void 0 : _a.initialize(JSON.stringify(Object.assign(Object.assign({}, JSON.parse(this.config)), { executionContext: this.executionContext })));
+    }
+    execute(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.executionContext) {
+                throw new Error('Execution context missing');
+            }
+            // If the module is not initialized, try to load it
+            if (!this.module) {
+                try {
+                    yield this.load();
+                }
+                catch (_a) {
+                    throw new Error('Module not initialized');
+                }
+            }
+            // If the module is still not initialized, throw an error
+            if (!this.module)
+                throw new Error('Module not initialized');
+            // Call the main function with the response
+            return this.module.execute(response);
+        });
+    }
+    // Makes contract instance and calls, returns stringified result
+    //   public async view(config: any): Promise<string> {
+    //     const contract = new Contract(config.address, config.abi, this.identityManager.wallet);
+    //     // For formatting the parameters if needed
+    //     const paramsArray = config.arguments;
+    //     // Calculate block number for determinism
+    //     // const syncedBlock = await getBlockFromTimestamp(this.timestamp,this.identityManager) //@note uncomment for deterministic blocks
+    //     // Call the desired method with the specified arguements at synced block
+    //     const result = await contract[config.method](...paramsArray); //, {blockTag: syncedBlock}) //@note uncomment for deterministic blocks
+    //     // This gets stringified before calling main
+    //     return result;
+    //   }
+    getResults() {
+        if (!this.module)
+            throw new Error('Module not initialized');
+        return this.module.transform();
+    }
+    version() {
+        if (!this.module)
+            throw new Error('Module not initialized');
+        return this.module.version();
+    }
+    subtractDate(timestamp, epochLength) {
+        const date = new Date(timestamp);
+        date.setSeconds(date.getSeconds() - epochLength);
+        return date;
+    }
+}
+exports.DataConnector = DataConnector;

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import { DataConnector } from './dataConnector';
+export declare class DataConnectorExecution {
+    private dataConnector;
+    constructor(dataConnector: DataConnector);
+    execute<T>(vaultAddress: string, _vaultConfig: string): Promise<Array<T>>;
+    private downloadWasmBundle;
+}

package/lib/index.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataConnectorExecution = void 0;
+const axios_1 = __importDefault(require("axios"));
+class DataConnectorExecution {
+    constructor(dataConnector) {
+        this.dataConnector = dataConnector;
+    }
+    execute(vaultAddress, _vaultConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // get current timestamp
+            const executionTimestamp = new Date().getTime();
+            // get vault configuration
+            const vaultConfig = JSON.parse(_vaultConfig);
+            // get data connector configurations
+            const dataConnectorConfigs = vaultConfig.dataConnectorsData;
+            // Each data connector results will be pushed into single array
+            // they will passed to execution bundle
+            const transformationData = [];
+            // Iterate over each data connector
+            for (const connectorConfig of dataConnectorConfigs) {
+                // If bundle hash is not present, skip the data connector
+                if (!connectorConfig.bundleHash) {
+                    continue;
+                }
+                this.dataConnector.setExecutionContext({
+                    executionTimestamp,
+                    epochLength: Number(vaultConfig.strategyConfigData.epochLength)
+                });
+                // Append vault address to config
+                if (vaultAddress) {
+                    connectorConfig.configData.vaultAddress = vaultAddress;
+                }
+                // loading data connector
+                if (!this.dataConnector.module) {
+                    yield this.dataConnector.load();
+                }
+                // get first request
+                let request = yield this.dataConnector.execute('');
+                let response;
+                while (request != 'true') {
+                    const parsedRequest = JSON.parse(request);
+                    // On Chain
+                    // if (this.dataConnector.configObj.isChainRead == true) {
+                    //   response = await this.dataConnector.view(parsedRequest);
+                    // } else {
+                    // Axios logic (off-chain)
+                    const ax_instance = axios_1.default.create();
+                    response = (yield ax_instance.request(parsedRequest)).data;
+                    // }
+                    // break;
+                    request = yield this.dataConnector.execute(JSON.stringify(response));
+                }
+                const totData = JSON.parse(this.dataConnector.getResults());
+                transformationData.push(totData);
+            }
+            return transformationData;
+        });
+    }
+    downloadWasmBundle(ipfsHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.get(`https://steerprotocol.mypinata.cloud/ipfs/${ipfsHash}`, {
+                responseType: 'arraybuffer',
+            });
+            const wasmFile = new Uint8Array(response.data);
+            return wasmFile;
+        });
+    }
+}
+exports.DataConnectorExecution = DataConnectorExecution;

package/lib/types.d.ts

@@ -0,0 +1,51 @@
+export type VaultInput = {
+    _id?: string;
+    tokenId: string;
+    vaultAddress: string;
+    state: string;
+    token0: string;
+    token1: string;
+    name: string;
+    symbol: string;
+    beaconName: string;
+    token0Name: string;
+    token1Name: string;
+    token0Symbol: string;
+    token1Symbol: string;
+    decimals: string;
+    token0Decimals: string;
+    token1Decimals: string;
+    payloadIpfs: string;
+    timestamp: number;
+    vaultConfigPayload: VaultConfigPayload;
+};
+export interface VaultConfigPayload {
+    strategyConfigData: StrategyConfigData;
+    vaultPayload: VaultPayload;
+    dataConnectorsData: DataConnectorsDaum[];
+}
+export interface StrategyConfigData {
+    [key: string]: string | number;
+    epochStart: number;
+    epochLength: string;
+}
+export interface ConcentratedLiquidityManagerPayload {
+    maxTotalSupply: string;
+    ratioErrorTolerance: number;
+    maxTickChange: number;
+    twapInterval: number;
+    fee: number;
+    slippage: number;
+}
+export type VaultPayload = ConcentratedLiquidityManagerPayload;
+export interface DataConnectorsDaum {
+    bundleHash: string;
+    configData: ConfigData;
+}
+export interface ConfigData {
+    [key: string]: string | number;
+}
+export interface ExecutionContext {
+    executionTimestamp: number;
+    epochLength: number;
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@steerprotocol/data-connector-loader",
+  "version": "0.0.1",
+  "description": "App Loader for Steer Protocol",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.(js|ts)\"",
+    "lint": "eslint src --ext .js,.ts",
+    "lint:fix": "eslint src --fix --ext .js,.ts",
+    "test": "jest --config jest.config.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm test && npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src",
+    "postversion": "git push && git push --tags"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SteerProtocol/data-connector-loader.git"
+  },
+  "keywords": [
+    "boilerplate",
+    "typescript"
+  ],
+  "author": "Hebert Cisco",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/SteerProtocol/data-connector-loader/issues"
+  },
+  "homepage": "https://github.com/SteerProtocol/data-connector-loader#readme",
+  "devDependencies": {
+    "@types/jest": "29.2.4",
+    "@typescript-eslint/eslint-plugin": "5.46.0",
+    "@typescript-eslint/parser": "5.47.1",
+    "date-fns": "^2.29.3",
+    "eslint": "8.30.0",
+    "eslint-plugin-jest": "27.1.7",
+    "jest": "29.3.1",
+    "prettier": "2.8.1",
+    "ts-jest": "29.0.3",
+    "typescript": "4.9.4"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "dependencies": {
+    "@steerprotocol/app-loader": "^0.0.9",
+    "@steerprotocol/strategy-utils": "^2.1.0",
+    "axios": "^1.3.2",
+    "ethers": "^6.0.3",
+    "pondjs": "1.0.0-alpha.10"
+  }
+}