@ultrade/shared 1.0.0

package/dist/common/migration.helpers.d.ts

@@ -0,0 +1,4 @@
+import { QueryRunner } from "typeorm";
+export declare function dropIndexIfExists(queryRunner: QueryRunner, tableName: string, indexName: string): Promise<void>;
+export declare function createIndexIfNotExists(queryRunner: QueryRunner, tableName: string, indexName: string, cols: string): Promise<void>;
+export declare function checkIfExists(queryRunner: QueryRunner, tableName: string, indexName: string): Promise<boolean>;

package/dist/common/migration.helpers.js

@@ -0,0 +1,44 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.dropIndexIfExists = dropIndexIfExists;
+exports.createIndexIfNotExists = createIndexIfNotExists;
+exports.checkIfExists = checkIfExists;
+async function dropIndexIfExists(queryRunner, tableName, indexName) {
+    if (await checkIfExists(queryRunner, tableName, indexName)) {
+        await queryRunner.query(`ALTER TABLE \`${tableName}\` DROP index \`${indexName}\``);
+    }
+}
+async function createIndexIfNotExists(queryRunner, tableName, indexName, cols) {
+    if (!(await checkIfExists(queryRunner, tableName, indexName))) {
+        await queryRunner.query(`CREATE INDEX \`${indexName}\` ON \`${tableName}\` (${cols});`);
+    }
+}
+async function checkIfExists(queryRunner, tableName, indexName) {
+    let result = await queryRunner.query(`SELECT EXISTS(SELECT * FROM INFORMATION_SCHEMA.STATISTICS  WHERE TABLE_NAME = '${tableName}'
+  AND INDEX_NAME = '${indexName}' AND INDEX_SCHEMA='order_service') as existed`);
+    console.log(result);
+    return result.length > 0 && result[0].existed == 1;
+}
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/redis.helper.d.ts

@@ -0,0 +1,27 @@
+import Redis from 'ioredis';
+declare class RedisHelper {
+    private host;
+    private port;
+    client: Redis;
+    private operationQueue;
+    private runningOperations;
+    constructor();
+    private performPendingOperations;
+    setString(key: string, value: string, expires?: number, database?: string): Promise<void>;
+    incrementKey(key: string, expires?: number, database?: string): Promise<void>;
+    scanKeys(pattern: string, database?: string): Promise<string[]>;
+    getString(key: string, database?: string): Promise<string | null>;
+    deleteString(key: string, database?: string): Promise<void>;
+    deleteByKeyPattern(pattern: string, database?: string): Promise<void>;
+    destroyDb(dbKey: string): Promise<boolean>;
+    private performOperation;
+    close(): Promise<void>;
+    createStream(key: string): Promise<void>;
+    writeToStream(key: string, message: object): Promise<void>;
+    readStream<T>(key: string, timeout: number): Promise<T>;
+    deleteStream(key: string): Promise<void>;
+    setTTL(key: string, ttlSeconds: number): Promise<void>;
+    streamExists(key: string): Promise<boolean>;
+}
+declare const _default: RedisHelper;
+export default _default;

package/dist/common/redis.helper.js

@@ -0,0 +1,269 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("ioredis"));
+	else if(typeof define === 'function' && define.amd)
+		define(["ioredis"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("ioredis")) : factory(root["ioredis"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, (__WEBPACK_EXTERNAL_MODULE__6615__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 5281:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const ioredis_1 = __importDefault(__webpack_require__(6615));
+class RedisHelper {
+    constructor() {
+        this.host = process.env.REDIS_HOSTNAME;
+        this.port = process.env.REDIS_PORT;
+        this.client = new ioredis_1.default({
+            host: this.host,
+            port: Number(this.port),
+            lazyConnect: true,
+        });
+        this.operationQueue = [];
+        this.runningOperations = false;
+        this.client.on('connect', () => {
+            // console.log('Redis Connected');
+        });
+        this.client.on('ready', () => {
+            // console.log('Redis Ready');
+            this.performPendingOperations();
+        });
+        this.client.on('error', (err) => {
+            console.error('Redis error:', err.message);
+        });
+        this.client.on('close', () => {
+            console.log('Redis connection closed');
+        });
+    }
+    async performPendingOperations() {
+        this.runningOperations = true;
+        while (this.operationQueue.length > 0) {
+            const operation = this.operationQueue.shift();
+            if (operation) {
+                try {
+                    await operation();
+                }
+                catch (err) {
+                    console.error('Error performing Redis operation:', err);
+                }
+            }
+        }
+        this.runningOperations = false;
+    }
+    async setString(key, value, expires = 0, database = '') {
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            await this.client.set(key, value);
+            if (expires !== 0) {
+                await this.client.expire(key, expires * 60);
+            }
+        };
+        await this.performOperation(operation);
+    }
+    async incrementKey(key, expires = 0, database = '') {
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            await this.client.incr(key);
+            if (expires !== 0) {
+                const ttl = await this.client.ttl(key);
+                if (ttl === -1) {
+                    await this.client.expire(key, expires * 60);
+                }
+            }
+        };
+        await this.performOperation(operation);
+    }
+    async scanKeys(pattern, database = '') {
+        const matchedKeys = [];
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            let cursor = '0';
+            do {
+                const [nextCursor, keys] = await this.client.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+                cursor = nextCursor;
+                matchedKeys.push(...keys);
+            } while (cursor !== '0');
+        };
+        await this.performOperation(operation);
+        return matchedKeys;
+    }
+    getString(key, database = '') {
+        return new Promise(async (resolve, reject) => {
+            const operation = async () => {
+                try {
+                    if (database !== '') {
+                        await this.client.select(Number(database));
+                    }
+                    const value = await this.client.get(key);
+                    resolve(value);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            this.performOperation(operation);
+        });
+    }
+    async deleteString(key, database = '') {
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            await this.client.del(key);
+        };
+        await this.performOperation(operation);
+    }
+    async deleteByKeyPattern(pattern, database = '') {
+        const operation = async () => {
+            if (database !== '') {
+                this.client.select(Number(database));
+            }
+            const keys = await this.client.keys(pattern);
+            if (keys.length > 0) {
+                await this.client.unlink(keys);
+                console.log(`Deleted ${keys.length} keys`);
+            }
+            else {
+                console.log('No keys for delete');
+            }
+        };
+        await this.performOperation(operation);
+    }
+    async destroyDb(dbKey) {
+        const response = await this.client.del(dbKey);
+        return response === 1;
+    }
+    async performOperation(operation) {
+        this.operationQueue.push(operation);
+        if (!this.runningOperations) {
+            try {
+                await this.performPendingOperations();
+            }
+            catch (error) {
+                console.error('Error during performing Redis operation', error);
+            }
+        }
+    }
+    async close() {
+        console.log('Closing Redis client for graceful shutdown...');
+        try {
+            while (this.operationQueue.length > 0 || this.runningOperations) {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            await this.client.quit();
+            console.log('Redis client closed successfully');
+        }
+        catch (error) {
+            console.error('Error during Redis client shutdown:', error);
+        }
+    }
+    async createStream(key) {
+        // console.log(`[Stream '${key}'] Creating...`);
+        await this.client.xgroup('CREATE', key, 'group', '$', 'MKSTREAM');
+    }
+    async writeToStream(key, message) {
+        try {
+            // console.log(`[Stream '${key}']`, `Try write to stream`);
+            if (await this.streamExists(key)) {
+                // console.log(`[Stream '${key}']`, `Writing the message`, JSON.stringify(message));
+                await this.client.xadd(key, '*', 'message', JSON.stringify(message));
+            }
+        }
+        catch (error) {
+            console.log(`[Stream '${key}']`, 'Error while writing to stream', error);
+        }
+    }
+    async readStream(key, timeout) {
+        // console.log(`[Stream '${key}'] Reading with timeout ${timeout}s...`);
+        const results = await this.client.xreadgroup('GROUP', 'group', 'consumer', 'COUNT', 1, 'BLOCK', timeout * 1000, 'STREAMS', key, '>');
+        if (results && results.length > 0) {
+            const [, entries] = results[0];
+            if (entries && entries.length > 0) {
+                const [, [, message]] = entries[0];
+                return JSON.parse(message);
+            }
+        }
+        return null;
+    }
+    async deleteStream(key) {
+        // console.log(`[Stream '${key}']`, `Try delete stream`);
+        if (await this.streamExists(key)) {
+            // console.log(`[Stream '${key}']`, `Deleting...`);
+            await this.client.del(key);
+        }
+    }
+    async setTTL(key, ttlSeconds) {
+        await this.client.expire(key, ttlSeconds);
+    }
+    async streamExists(key) {
+        const exists = await this.client.exists(key);
+        // console.log(`Key '${key}' in redis exists: ${exists}`);
+        return exists === 1;
+    }
+}
+exports["default"] = new RedisHelper();
+
+
+/***/ }),
+
+/***/ 6615:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__6615__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(5281);
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/secret.helper.d.ts

@@ -0,0 +1,28 @@
+interface RelayerSecrets {
+    algorand: string;
+    polygon: string;
+    solana: string;
+}
+export interface OndatoSecrets {
+    clientId: string;
+    clientSecret: string;
+    hmacSecret: string;
+    setupId: string;
+}
+declare class SecretHelper {
+    private creatorMnemonicSecretName;
+    private dispenserMnemonicSecretName;
+    private transactionMnemonicSecretName;
+    private relayerMnemonicSecretName;
+    private ondatoCredentialsSecretName;
+    getCreatorMnemonic(): Promise<string>;
+    getDispenserMnemonic(): Promise<string>;
+    getTransactionMnemonic(): Promise<string>;
+    getRelayerMnemonics(): Promise<RelayerSecrets>;
+    getOndatoSecrets(): Promise<OndatoSecrets>;
+    private getClient;
+    private getSecrets;
+    saveSecret(secretName: string, secretValue: string): Promise<void>;
+}
+declare const _default: SecretHelper;
+export default _default;

package/dist/common/secret.helper.js

@@ -0,0 +1,144 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@aws-sdk/client-secrets-manager"));
+	else if(typeof define === 'function' && define.amd)
+		define(["@aws-sdk/client-secrets-manager"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("@aws-sdk/client-secrets-manager")) : factory(root["@aws-sdk/client-secrets-manager"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, (__WEBPACK_EXTERNAL_MODULE__2216__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 2216:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__2216__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const client_secrets_manager_1 = __webpack_require__(2216);
+class SecretHelper {
+    constructor() {
+        this.creatorMnemonicSecretName = process.env.CreatorSecret;
+        this.dispenserMnemonicSecretName = process.env.DispenserSecret;
+        this.transactionMnemonicSecretName = process.env.TransactionSecret;
+        this.relayerMnemonicSecretName = process.env.RelayerSecret;
+        this.ondatoCredentialsSecretName = process.env.OndatoSecret;
+    }
+    async getCreatorMnemonic() {
+        const creatorMnemonic = await this.getSecrets(this.creatorMnemonicSecretName);
+        return JSON.parse(creatorMnemonic).creator;
+    }
+    async getDispenserMnemonic() {
+        const dispenserMnemonic = await this.getSecrets(this.dispenserMnemonicSecretName);
+        return JSON.parse(dispenserMnemonic).dispenser;
+    }
+    async getTransactionMnemonic() {
+        const transactionMnemonic = await this.getSecrets(this.transactionMnemonicSecretName);
+        return JSON.parse(transactionMnemonic).txs;
+    }
+    async getRelayerMnemonics() {
+        const relayerMnemonic = await this.getSecrets(this.relayerMnemonicSecretName);
+        return JSON.parse(relayerMnemonic);
+    }
+    async getOndatoSecrets() {
+        const ondatoSecrets = await this.getSecrets(this.ondatoCredentialsSecretName);
+        return JSON.parse(ondatoSecrets);
+    }
+    getClient() {
+        return new client_secrets_manager_1.SecretsManager({ region: 'us-east-1' });
+    }
+    getSecrets(secretName) {
+        // console.log(`Getting secrets by name: ${secretName}`);
+        return new Promise((resolve, reject) => {
+            try {
+                const command = new client_secrets_manager_1.GetSecretValueCommand({ SecretId: secretName });
+                const client = this.getClient();
+                client.send(command, (err, data) => {
+                    if (err) {
+                        console.log('-----error in secrets---------', err);
+                        reject(err);
+                    }
+                    else {
+                        // console.log('secrets successfully received');
+                        resolve(data.SecretString);
+                    }
+                });
+            }
+            catch (error) {
+                console.log('error curl', error);
+                reject(error);
+            }
+        });
+    }
+    saveSecret(secretName, secretValue) {
+        console.log(`Saving secret with name: ${secretName}`);
+        return new Promise((resolve, reject) => {
+            try {
+                const command = new client_secrets_manager_1.PutSecretValueCommand({
+                    SecretId: secretName,
+                    SecretString: secretValue,
+                });
+                const client = this.getClient();
+                client.send(command, (err, data) => {
+                    if (err) {
+                        console.log('-----error in saving secret---------', err);
+                        reject(err);
+                    }
+                    else {
+                        console.log('secret successfully saved');
+                        resolve();
+                    }
+                });
+            }
+            catch (error) {
+                console.log('error curl', error);
+                reject(error);
+            }
+        });
+    }
+}
+exports["default"] = new SecretHelper();
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/timestamp.helper.d.ts

@@ -0,0 +1 @@
+export declare function timestamp(accuracy?: "micro" | "nano"): string;

package/dist/common/timestamp.helper.js

@@ -0,0 +1,41 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.timestamp = timestamp;
+const startTime = BigInt(Date.now());
+const startHrTime = process.hrtime.bigint();
+function timestamp(accuracy = 'micro') {
+    const elapsedNano = process.hrtime.bigint() - startHrTime;
+    const baseTimestampNano = startTime * 10n ** 6n + elapsedNano;
+    const baseString = baseTimestampNano.toString();
+    let result;
+    if (accuracy === "micro") {
+        result = `${baseString.slice(0, -6)}.${baseString.slice(-6, -3)}`;
+    }
+    else {
+        result = `${baseString.slice(0, -6)}.${baseString.slice(-6)}`;
+    }
+    return result;
+}
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/utils/assert.d.ts

@@ -0,0 +1 @@
+export declare const assert: (condition: boolean, message: string) => void;

package/dist/common/utils/assert.js

@@ -0,0 +1,32 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.assert = void 0;
+const assert = (condition, message) => {
+    if (!condition) {
+        throw new Error(`Assertion error: ${message}`);
+    }
+};
+exports.assert = assert;
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/utils/decode.d.ts

@@ -0,0 +1,5 @@
+import { AlgoOrder } from "../../types/algo-order.type";
+export declare const getAccounInfoFormLocalStorage: (localState: any) => any;
+export declare function unpackData(data: any, format: any): any;
+export declare function decodeString(value: Uint8Array): string;
+export declare const printUnpackedLocalData: (localState: any) => Array<AlgoOrder>;