@ultrade/shared 1.0.0

package/dist/enums/maintenanceMode.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum MaintenanceMode {
+    Off = 0,
+    Full = 1,
+    Partial = 2,
+    Scheduled = 3
+}
+export type MaintenanceStatus = {
+    mode: MaintenanceMode;
+    scheduledDate?: Date;
+};

package/dist/enums/notification.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum Notification {
+    SELF_TRADE = 1,
+    FULL_FILLED = 2,
+    FULL_CANCELLED = 3,
+    PARTIALLY_CANCELLED = 4,
+    CREATED = 5
+}

package/dist/enums/social.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum TwitterAccessScopeEnum {
+    USERS_READ = "users.read",
+    FOLLOWS_READ = "follows.read",
+    FOLLOWS_WRITE = "follows.write",
+    TWEET_READ = "tweet.read",
+    TWEET_WRITE = "tweet.write",
+    OFFLINE_ACCESS = "offline.access",
+    LIKE_READ = "like.read",
+    LIKE_WRITE = "like.write"
+}

package/dist/helpers/Encoding.d.ts

@@ -0,0 +1,33 @@
+export type AlgorandType = bigint | string | boolean | number | Uint8Array;
+export type IPackedInfoFixed = {
+    type: "uint" | "number" | "address" | "double";
+};
+export type IPackedInfoVariable = {
+    type: "string" | "bytes";
+    size: number;
+};
+export type IPackedInfoAny = IPackedInfoFixed | IPackedInfoVariable;
+export type IPackedInfo = {
+    [name: string]: IPackedInfoAny;
+};
+export declare function concatArrays(arrays: Uint8Array[]): Uint8Array;
+export declare function packData(value: {
+    [index: string]: any;
+}, format: IPackedInfo): Uint8Array;
+export declare function unpackData(data: Uint8Array, format: IPackedInfo): {
+    [index: string]: any;
+};
+export declare function encodeArgArray(params: AlgorandType[]): Uint8Array[];
+export declare function encodeString(value: string | Uint8Array): Uint8Array;
+export declare function decodeString(value: Uint8Array): string;
+export declare function encode32Bytes(value: number): Uint8Array;
+export declare function encodeUint64(value: number | bigint): Uint8Array;
+export declare function decodeUint64(value: Uint8Array): bigint;
+export declare function encodeBase64(value: Uint8Array): string;
+export declare function decodeBase64(value: string): Uint8Array;
+export declare function compareArrays(a: [], b: Uint8Array[]): boolean;
+export declare function getDeltaUint(response: any, key: string): bigint | undefined;
+export declare function getDeltaBytes(response: any, key: string): Uint8Array | undefined;
+export declare function toUnix(date: Date): number;
+export declare function fromUnix(timestamp: number): Date;
+export { encodeAddress, decodeAddress } from 'algosdk';

package/dist/helpers/Encoding.js

@@ -0,0 +1,318 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("buffer"), require("algosdk"));
+	else if(typeof define === 'function' && define.amd)
+		define(["buffer", "algosdk"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("buffer"), require("algosdk")) : factory(root["buffer"], root["algosdk"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, (__WEBPACK_EXTERNAL_MODULE__18__, __WEBPACK_EXTERNAL_MODULE__9709__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 18:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__18__;
+
+/***/ }),
+
+/***/ 8593:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.decodeAddress = exports.encodeAddress = void 0;
+exports.concatArrays = concatArrays;
+exports.packData = packData;
+exports.unpackData = unpackData;
+exports.encodeArgArray = encodeArgArray;
+exports.encodeString = encodeString;
+exports.decodeString = decodeString;
+exports.encode32Bytes = encode32Bytes;
+exports.encodeUint64 = encodeUint64;
+exports.decodeUint64 = decodeUint64;
+exports.encodeBase64 = encodeBase64;
+exports.decodeBase64 = decodeBase64;
+exports.compareArrays = compareArrays;
+exports.getDeltaUint = getDeltaUint;
+exports.getDeltaBytes = getDeltaBytes;
+exports.toUnix = toUnix;
+exports.fromUnix = fromUnix;
+const algosdk_1 = __importStar(__webpack_require__(9709));
+// import sha512 from "js-sha512"
+const buffer_1 = __webpack_require__(18);
+function concatArrays(arrays) {
+    return arrays.reduce((a, b) => Uint8Array.from([...a, ...b]));
+}
+function packData(value, format) {
+    const chunks = [];
+    for (const [name, type] of Object.entries(format)) {
+        const v = value[name];
+        if (v === undefined) {
+            throw new Error(`Key ${name} missing from value`);
+        }
+        switch (type.type) {
+            case 'address':
+                if (v instanceof Uint8Array && v.length == 32) {
+                    chunks.push(v);
+                    break;
+                }
+                else if (typeof v === 'string') {
+                    chunks.push((0, algosdk_1.decodeAddress)(v).publicKey);
+                }
+                else {
+                    throw new Error(`${name}: Expected address, got ${v}`);
+                }
+                break;
+            case 'bytes':
+                if (v instanceof Uint8Array) {
+                    if (v.length == type.size) {
+                        chunks.push(v);
+                        break;
+                    }
+                    else {
+                        throw new Error(`${name}: Bytes length is wrong, expected ${type.size}, got ${v.length}`);
+                    }
+                }
+                else {
+                    throw new Error(`${name}: Expected bytes[${type.size}], got ${v}`);
+                }
+            case 'double':
+                if (typeof v === 'number') {
+                    const bytes = new ArrayBuffer(8);
+                    buffer_1.Buffer.from(bytes).writeDoubleLE(v, 0);
+                    chunks.push(new Uint8Array(bytes));
+                    break;
+                }
+                else {
+                    throw new Error(`${name}: Expected double, got ${v}`);
+                }
+            case 'number':
+            case 'uint':
+                if (typeof v === 'bigint' || typeof v === 'number') {
+                    chunks.push(encodeUint64(v));
+                    break;
+                }
+                else {
+                    throw new Error(`${name}: Expected uint or number, got ${v}`);
+                }
+            case 'string':
+                if (typeof v === 'string') {
+                    const str = encodeString(v);
+                    if (str.length == type.size) {
+                        chunks.push(str);
+                        break;
+                    }
+                    else {
+                        throw new Error(`${name}: Expected string length ${type.size}, got string length ${str.length}`);
+                    }
+                }
+                else {
+                    throw new Error(`${name}: Expected string length ${type.size}, got ${v}`);
+                }
+        }
+    }
+    return concatArrays(chunks);
+}
+function unpackData(data, format) {
+    const result = new Map();
+    let index = 0;
+    for (const [name, type] of Object.entries(format)) {
+        if (index >= data.length) {
+            throw new Error('Array index out of bounds');
+        }
+        let value;
+        switch (type.type) {
+            case 'address':
+                value = (0, algosdk_1.encodeAddress)(data.slice(index, index + 32));
+                index += 32;
+                break;
+            case 'bytes':
+                value = data.slice(index, index + type.size);
+                index += type.size;
+                break;
+            case 'double':
+                value = buffer_1.Buffer.from(data.slice(index, index + 8)).readDoubleLE(0);
+                index += 8;
+                break;
+            case 'number':
+                value = Number(decodeUint64(data.slice(index, index + 8)));
+                index += 8;
+                break;
+            case 'uint':
+                value = decodeUint64(data.slice(index, index + 8));
+                index += 8;
+                break;
+            case 'string':
+                value = decodeString(data.slice(index, index + type.size));
+                index += type.size;
+                break;
+        }
+        result.set(name, value);
+    }
+    return Object.fromEntries(result);
+}
+function encodeArgArray(params) {
+    return params.map(param => {
+        if (param instanceof Uint8Array)
+            return new Uint8Array(param);
+        if (typeof param === "string")
+            return encodeString(param);
+        if (typeof param === "boolean")
+            param = BigInt(param ? 1 : 0);
+        if (typeof param === "number")
+            param = BigInt(param);
+        return encodeUint64(param);
+    });
+}
+function encodeString(value) {
+    return new Uint8Array(buffer_1.Buffer.from(value));
+}
+function decodeString(value) {
+    return buffer_1.Buffer.from(value).toString('utf-8');
+}
+function encode32Bytes(value) {
+    const valueButes = algosdk_1.default.encodeUint64(value);
+    return concatArrays([new Uint8Array(32 - valueButes.length), valueButes]);
+}
+function encodeUint64(value) {
+    const bytes = buffer_1.Buffer.alloc(8);
+    for (let index = 0; index < 8; index++)
+        bytes[7 - index] = Number((BigInt(value) >> BigInt(index * 8)) & BigInt(0xFF));
+    return new Uint8Array(bytes);
+}
+function decodeUint64(value) {
+    let num = BigInt(0);
+    for (let index = 0; index < 8 && value?.length; index++)
+        num = (num << BigInt(8)) | BigInt(value[index]);
+    return num;
+}
+function encodeBase64(value) {
+    return buffer_1.Buffer.from(value).toString('base64');
+}
+function decodeBase64(value) {
+    return buffer_1.Buffer.from(value, 'base64');
+}
+// export const sha256HashLength = 32
+// export function sha256Hash(arr: sha512.Message): Uint8Array {
+//     return new Uint8Array(sha512.sha512_256.arrayBuffer(arr))
+// }
+// export function encodeApplicationAddress(id: number): Address {
+//     const APP_ID_PREFIX = Buffer.from('appID');
+//     const toBeSigned = concatArrays([APP_ID_PREFIX, encodeUint64(BigInt(id))]);
+//     return encodeAddress(sha256Hash(toBeSigned));
+// }
+function compareArrays(a, b) {
+    return a.length === b.length && a.reduce((equal, item, index) => equal && item === b[index], true);
+}
+function getDelta(response, key) {
+    const delta = response['global-state-delta'].find((v) => v.key === key);
+    if (delta === undefined)
+        return undefined;
+    return delta['value'];
+}
+function getDeltaUint(response, key) {
+    const delta = getDelta(response, key);
+    if (delta === undefined)
+        return undefined;
+    return BigInt(delta['uint']);
+}
+function getDeltaBytes(response, key) {
+    const delta = getDelta(response, key);
+    if (delta === undefined)
+        return undefined;
+    return decodeBase64(delta['bytes']);
+}
+function toUnix(date) {
+    return Math.floor(date.getTime() / 1000);
+}
+function fromUnix(timestamp) {
+    return new Date(timestamp * 1000);
+}
+var algosdk_2 = __webpack_require__(9709);
+Object.defineProperty(exports, "encodeAddress", ({ enumerable: true, get: function () { return algosdk_2.encodeAddress; } }));
+Object.defineProperty(exports, "decodeAddress", ({ enumerable: true, get: function () { return algosdk_2.decodeAddress; } }));
+
+
+/***/ }),
+
+/***/ 9709:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__9709__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// 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__(8593);
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/helpers/algo.helper.d.ts

@@ -0,0 +1,14 @@
+import algosdk from 'algosdk';
+export declare const createBoxes: (appIndex: number, foreignApps: number[]) => {
+    appIndex: number;
+    name: Uint8Array<ArrayBufferLike>;
+}[];
+export declare function decodeStateArray(stateArray: any[]): {};
+export declare const getAccountAssetBalances: (accountInfo: any) => Record<string, number>;
+export declare const getAppGlobalState: (algodClient: algosdk.Algodv2, appId: number) => Promise<{}>;
+export declare const getAppBoxes: (algodClient: algosdk.Algodv2, appId: number) => Promise<void>;
+export declare const getBoxByName: (algoClient: algosdk.Algodv2, appId: number, boxName: Uint8Array) => Promise<Uint8Array | null>;
+export declare const getTxnParams: (algoClient: algosdk.Algodv2, txnsCount?: number) => Promise<algosdk.SuggestedParams>;
+export declare const isAssetOptedIn: (balances: Record<string, number>, assetId: number) => boolean;
+export declare const decodeAndNormalizeAddress: (address: string) => Uint8Array;
+export declare const verifySignature: (signature: string, address: string, message: string, encoding?: BufferEncoding) => boolean;