locuschain-lib 1.0.4

package/README.md

@@ -0,0 +1,33 @@
+# locuschain-lib
+---
+This is a library that includes functions necessary for applying the `Locus Chain` to your service. The following features are included:
+
+- Generate or load keys.
+- Convert to data types used in Locus Chain.
+- Validate transactions.
+- Encode data.
+
+## Installation
+
+```shell
+npm i locuschain-lib
+```
+
+## Usage
+
+LocusLib.`function`(`params`)
+
+- **function:** Function
+- **params:** Parameter
+
+```typescript
+import { LocusLib } from 'locuschain-lib';
+const result = await LocusLib.GetLibraryVersions()
+console.log(result)
+```
+
+:::tip
+All functions are asynchronous. Use await before them or use then to receive the result.
+:::
+
+You can find the list of functions and detailed descriptions in the official Locus Chain documentation.

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { MerkleProof, ParamTxData } from './types.ts';
+export declare class LocusLib {
+    static callWasm(wasmCmd: string, wasmParams: any): Promise<unknown>;
+    static GetLibraryVersions(): Promise<unknown>;
+    static CreateAccountAndKeystore(passwordMaster: string, passwordNormal: string, mkeyAlgoNormal: string, nkeyAlgoNormal: string): Promise<unknown>;
+    static CreateNormalKey(addrStr: any, keyAlgo: string): Promise<unknown>;
+    static CreateMasterKeystore(AddrStr: any, Password: any, MskStr: any, MpkStr: any): Promise<unknown>;
+    static CreateNormalKeystore(AddrStr: any, Password: any, NskStr: any, NpkStr: any, MpkStr?: any, KeySign?: any): Promise<unknown>;
+    static LoadMasterKeystore(PassStr: string, KsJson: string): Promise<unknown>;
+    static LoadNormalKeystore(PassStr: string, KsJson: string): Promise<unknown>;
+    static ConvertToData(value: string, valueType: number): Promise<unknown>;
+    static ConvertDataTo(dataString: string, retType: number): Promise<unknown>;
+    static ConvertStringToData(str: string): Promise<unknown>;
+    static ConvertDataToString(dataString: string): Promise<unknown>;
+    static ConvertAddressToHex(addr: string): Promise<unknown>;
+    static ConvertHexToAddress(hexString: string): Promise<unknown>;
+    static ConvertAddressToData(addr: string): Promise<unknown>;
+    static ConvertDataToAddress(dataString: string): Promise<unknown>;
+    static ConvertBase32ToHex(encoded: string): Promise<unknown>;
+    static ConvertHexToBase32(hexString: string): Promise<unknown>;
+    static ConvertHexToData(encoded: string): Promise<unknown>;
+    static ConvertDataToHex(dataString: string): Promise<unknown>;
+    static ConvertBase32ToData(encoded: string): Promise<unknown>;
+    static ConvertDataToBase32(dataString: string): Promise<unknown>;
+    static SignByMasterKey(Msk: string, Message: string): Promise<unknown>;
+    static Sign(Sk: string, Message: string): Promise<unknown>;
+    static Verify(Pk: string, Message: string, Sig: string): Promise<unknown>;
+    static VerifyTx(jsonTx: string): Promise<unknown>;
+    static CompileCoreScript(Code: string): Promise<unknown>;
+    static DisCompileCoreScript(Code: string): Promise<unknown>;
+    static TestCoreScript(ScriptProvide: string, ScriptAccept: string, TxDataProvide: ParamTxData, TxDataAccept: ParamTxData): Promise<unknown>;
+    static GetDefFromCoreScript(Code: string): Promise<unknown>;
+    static EncodeTxNumber(Number: string, Type: number): Promise<unknown>;
+    static EncodeTxCurrency(Currency: string): Promise<unknown>;
+    static Hash(Data: string, Type: number): Promise<unknown>;
+    static VerifyMerkleProof(Proof: MerkleProof, Hash: string, GoalHash: string): Promise<unknown>;
+    static CalculateTxLinkHash(Tx: string): Promise<unknown>;
+    static DecodeTxs(Txs: string[]): Promise<unknown>;
+    static GzipAndEncode(str: string): Promise<unknown>;
+}

package/dist/index.js

@@ -0,0 +1,149 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocusLib = void 0;
+const tslib_1 = require("tslib");
+const lclib_js_1 = require("./lclib.js");
+(0, lclib_js_1.loadLocusLibrary)().then((res) => {
+});
+class LocusLib {
+    static callWasm(wasmCmd, wasmParams) {
+        return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (Array.isArray(wasmParams)) {
+                wasmParams = wasmParams[0];
+            }
+            // @ts-ignore
+            if (typeof globalThis['CallLclib'] !== "function")
+                return;
+            // @ts-ignore
+            const resultString = yield globalThis['CallLclib'](wasmCmd, JSON.stringify(wasmParams));
+            const result = JSON.parse(resultString);
+            if (result.Error && result.Error.Code != 0) {
+                reject(result.Error);
+            }
+            else {
+                resolve(result.Result);
+            }
+        }));
+    }
+    //=================================================================================
+    static GetLibraryVersions() {
+        return LocusLib.callWasm('GetLibraryVersions', {});
+    }
+    static CreateAccountAndKeystore(passwordMaster, passwordNormal, mkeyAlgoNormal, nkeyAlgoNormal) {
+        return LocusLib.callWasm('CreateAccountAndKeystore', {
+            passwordMaster,
+            passwordNormal,
+            mkeyAlgoNormal,
+            nkeyAlgoNormal
+        });
+    }
+    static CreateNormalKey(addrStr, keyAlgo) {
+        return LocusLib.callWasm('CreateNormalKey', { addrStr, keyAlgo });
+    }
+    static CreateMasterKeystore(AddrStr, Password, MskStr, MpkStr) {
+        return LocusLib.callWasm('CreateMasterKeystore', { AddrStr, Password, MskStr, MpkStr });
+    }
+    static CreateNormalKeystore(AddrStr, Password, NskStr, NpkStr, MpkStr = '', KeySign = '') {
+        return LocusLib.callWasm('CreateNormalKeystore', { AddrStr, Password, NskStr, NpkStr, MpkStr, KeySign });
+    }
+    static LoadMasterKeystore(PassStr, KsJson) {
+        return LocusLib.callWasm('LoadMasterKeystore', { PassStr, KsJson });
+    }
+    static LoadNormalKeystore(PassStr, KsJson) {
+        return LocusLib.callWasm('LoadNormalKeystore', { PassStr, KsJson });
+    }
+    static ConvertToData(value, valueType) {
+        return LocusLib.callWasm('ConvertToData', { value, valueType });
+    }
+    static ConvertDataTo(dataString, retType) {
+        return LocusLib.callWasm('ConvertDataTo', { dataString, retType });
+    }
+    static ConvertStringToData(str) {
+        return LocusLib.callWasm('ConvertStringToData', str);
+    }
+    static ConvertDataToString(dataString) {
+        return LocusLib.callWasm('ConvertDataToString', dataString);
+    }
+    static ConvertAddressToHex(addr) {
+        return LocusLib.callWasm('ConvertAddressToHex', addr);
+    }
+    static ConvertHexToAddress(hexString) {
+        return LocusLib.callWasm('ConvertHexToAddress', hexString);
+    }
+    static ConvertAddressToData(addr) {
+        return LocusLib.callWasm('ConvertAddressToData', addr);
+    }
+    static ConvertDataToAddress(dataString) {
+        return LocusLib.callWasm('ConvertDataToAddress', dataString);
+    }
+    static ConvertBase32ToHex(encoded) {
+        return LocusLib.callWasm('ConvertBase32ToHex', encoded);
+    }
+    static ConvertHexToBase32(hexString) {
+        return LocusLib.callWasm('ConvertHexToBase32', hexString);
+    }
+    static ConvertHexToData(encoded) {
+        return LocusLib.callWasm('ConvertHexToData', encoded);
+    }
+    static ConvertDataToHex(dataString) {
+        return LocusLib.callWasm('ConvertDataToHex', dataString);
+    }
+    static ConvertBase32ToData(encoded) {
+        return LocusLib.callWasm('ConvertBase32ToData', encoded);
+    }
+    static ConvertDataToBase32(dataString) {
+        return LocusLib.callWasm('ConvertDataToBase32', dataString);
+    }
+    static SignByMasterKey(Msk, Message) {
+        return LocusLib.callWasm('SignByMasterKey', { Msk, Message });
+    }
+    static Sign(Sk, Message) {
+        return LocusLib.callWasm('Sign', { Sk, Message });
+    }
+    static Verify(Pk, Message, Sig) {
+        return LocusLib.callWasm('Verify', { Pk, Message, Sig });
+    }
+    static VerifyTx(jsonTx) {
+        return LocusLib.callWasm('VerifyTx', jsonTx);
+    }
+    static CompileCoreScript(Code) {
+        return LocusLib.callWasm('CompileCoreScript', { Code });
+    }
+    static DisCompileCoreScript(Code) {
+        return LocusLib.callWasm('DisCompileCoreScript', { Code });
+    }
+    static TestCoreScript(ScriptProvide, ScriptAccept, TxDataProvide, TxDataAccept) {
+        return LocusLib.callWasm('TestCoreScript', {
+            ScriptProvide,
+            ScriptAccept,
+            TxDataProvide,
+            TxDataAccept
+        });
+    }
+    static GetDefFromCoreScript(Code) {
+        return LocusLib.callWasm('GetDefFromCoreScript', { Code });
+    }
+    static EncodeTxNumber(Number, Type) {
+        return LocusLib.callWasm('EncodeTxNumber', { Number, Type });
+    }
+    static EncodeTxCurrency(Currency) {
+        return LocusLib.callWasm('EncodeTxCurrency', { Currency });
+    }
+    static Hash(Data, Type) {
+        return LocusLib.callWasm('Hash', { Data, Type });
+    }
+    static VerifyMerkleProof(Proof, Hash, GoalHash) {
+        return LocusLib.callWasm('VerifyMerkleProof', { Proof, Hash, GoalHash });
+    }
+    static CalculateTxLinkHash(Tx) {
+        return LocusLib.callWasm('CalculateTxLinkHash', { Tx });
+    }
+    static DecodeTxs(Txs) {
+        return LocusLib.callWasm('DecodeTxs', { Txs });
+    }
+    static GzipAndEncode(str) {
+        return LocusLib.callWasm('GzipAndEncode', str);
+    }
+}
+exports.LocusLib = LocusLib;

package/dist/lclib.d.ts

@@ -0,0 +1 @@
+export function loadLocusLibrary(): Promise<any>;