locuschain-lib 1.1.3 → 1.1.5

package/dist/lclib-amd.js

@@ -1,840 +1,864 @@
 define(['exports'], (function (exports) { 'use strict';
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-    function __awaiter(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());
-        });
+  /* eslint-disable */
+
+
+  function toUint8Array(s) {
+    if (typeof atob === "function")
+      return new Uint8Array(atob(s).split("").map(charCodeAt));
+    // return (require('buf' + 'fer').Buffer).from(s, 'base64')
+  }
+
+  function charCodeAt(c) {
+    return c.charCodeAt(0);
+  }
+
+  const wasmJson = require("./lclib.json");
+  var wasm = toUint8Array(wasmJson.Base64);
+
+  (() => {
+    const enosys = () => {
+      const err = new Error("not implemented");
+      err.code = "ENOSYS";
+      return err;
+    };
+
+    if (!globalThis.fs) {
+      let outputBuf = "";
+      globalThis.fs = {
+        constants: {
+          O_WRONLY: -1,
+          O_RDWR: -1,
+          O_CREAT: -1,
+          O_TRUNC: -1,
+          O_APPEND: -1,
+          O_EXCL: -1,
+        }, // unused
+        writeSync(fd, buf) {
+          outputBuf += decoder.decode(buf);
+          const nl = outputBuf.lastIndexOf("\n");
+          if (nl != -1) {
+            console.log(outputBuf.substring(0, nl));
+            outputBuf = outputBuf.substring(nl + 1);
+          }
+          return buf.length;
+        },
+        write(fd, buf, offset, length, position, callback) {
+          if (offset !== 0 || length !== buf.length || position !== null) {
+            callback(enosys());
+            return;
+          }
+          const n = this.writeSync(fd, buf);
+          callback(null, n);
+        },
+        chmod(path, mode, callback) {
+          callback(enosys());
+        },
+        chown(path, uid, gid, callback) {
+          callback(enosys());
+        },
+        close(fd, callback) {
+          callback(enosys());
+        },
+        fchmod(fd, mode, callback) {
+          callback(enosys());
+        },
+        fchown(fd, uid, gid, callback) {
+          callback(enosys());
+        },
+        fstat(fd, callback) {
+          callback(enosys());
+        },
+        fsync(fd, callback) {
+          callback(null);
+        },
+        ftruncate(fd, length, callback) {
+          callback(enosys());
+        },
+        lchown(path, uid, gid, callback) {
+          callback(enosys());
+        },
+        link(path, link, callback) {
+          callback(enosys());
+        },
+        lstat(path, callback) {
+          callback(enosys());
+        },
+        mkdir(path, perm, callback) {
+          callback(enosys());
+        },
+        open(path, flags, mode, callback) {
+          callback(enosys());
+        },
+        read(fd, buffer, offset, length, position, callback) {
+          callback(enosys());
+        },
+        readdir(path, callback) {
+          callback(enosys());
+        },
+        readlink(path, callback) {
+          callback(enosys());
+        },
+        rename(from, to, callback) {
+          callback(enosys());
+        },
+        rmdir(path, callback) {
+          callback(enosys());
+        },
+        stat(path, callback) {
+          callback(enosys());
+        },
+        symlink(path, link, callback) {
+          callback(enosys());
+        },
+        truncate(path, length, callback) {
+          callback(enosys());
+        },
+        unlink(path, callback) {
+          callback(enosys());
+        },
+        utimes(path, atime, mtime, callback) {
+          callback(enosys());
+        },
+      };
     }
 
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
-    /* eslint-disable */
-
-
-    function toUint8Array (s) {
-      if (typeof atob === 'function') return new Uint8Array(atob(s).split('').map(charCodeAt))
-     // return (require('buf' + 'fer').Buffer).from(s, 'base64')
-    }
-
-    function charCodeAt (c) {
-      return c.charCodeAt(0)
-    }
-
-    const wasmJson = require('./lclib.json');
-    var wasm = toUint8Array(wasmJson.Base64);
-
-    (() => {
-      const enosys = () => {
-        const err = new Error('not implemented');
-        err.code = 'ENOSYS';
-        return err;
-      };
-
-      if (!globalThis.fs) {
-        let outputBuf = '';
-        globalThis.fs = {
-          constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 }, // unused
-          writeSync(fd, buf) {
-            outputBuf += decoder.decode(buf);
-            const nl = outputBuf.lastIndexOf('\n');
-            if (nl != -1) {
-              console.log(outputBuf.substring(0, nl));
-              outputBuf = outputBuf.substring(nl + 1);
-            }
-            return buf.length;
-          },
-          write(fd, buf, offset, length, position, callback) {
-            if (offset !== 0 || length !== buf.length || position !== null) {
-              callback(enosys());
+    // if (!globalThis.process) {
+    //   globalThis.process = {
+    //     getuid() {
+    //       return -1;
+    //     },
+    //     getgid() {
+    //       return -1;
+    //     },
+    //     geteuid() {
+    //       return -1;
+    //     },
+    //     getegid() {
+    //       return -1;
+    //     },
+    //     getgroups() {
+    //       throw enosys();
+    //     },
+    //     pid: -1,
+    //     ppid: -1,
+    //     umask() {
+    //       throw enosys();
+    //     },
+    //     cwd() {
+    //       throw enosys();
+    //     },
+    //     chdir() {
+    //       throw enosys();
+    //     }
+    //   };
+    // }
+
+    if (!globalThis.crypto) {
+      throw new Error(
+        "globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)"
+      );
+    }
+
+    if (!globalThis.performance) {
+      throw new Error(
+        "globalThis.performance is not available, polyfill required (performance.now only)"
+      );
+    }
+
+    if (!globalThis.TextEncoder) {
+      throw new Error(
+        "globalThis.TextEncoder is not available, polyfill required"
+      );
+    }
+
+    if (!globalThis.TextDecoder) {
+      throw new Error(
+        "globalThis.TextDecoder is not available, polyfill required"
+      );
+    }
+
+    const encoder = new TextEncoder("utf-8");
+    const decoder = new TextDecoder("utf-8");
+
+    globalThis.Go = class {
+      constructor() {
+        this.argv = ["js"];
+        this.env = {};
+        this.exit = (code) => {
+          if (code !== 0) {
+            console.warn("exit code:", code);
+          }
+        };
+        this._exitPromise = new Promise((resolve) => {
+          this._resolveExitPromise = resolve;
+        });
+        this._pendingEvent = null;
+        this._scheduledTimeouts = new Map();
+        this._nextCallbackTimeoutID = 1;
+
+        const setInt64 = (addr, v) => {
+          this.mem.setUint32(addr + 0, v, true);
+          this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
+        };
+
+        const getInt64 = (addr) => {
+          const low = this.mem.getUint32(addr + 0, true);
+          const high = this.mem.getInt32(addr + 4, true);
+          return low + high * 4294967296;
+        };
+
+        const loadValue = (addr) => {
+          const f = this.mem.getFloat64(addr, true);
+          if (f === 0) {
+            return undefined;
+          }
+          if (!isNaN(f)) {
+            return f;
+          }
+
+          const id = this.mem.getUint32(addr, true);
+          return this._values[id];
+        };
+
+        const storeValue = (addr, v) => {
+          const nanHead = 0x7ff80000;
+
+          if (typeof v === "number" && v !== 0) {
+            if (isNaN(v)) {
+              this.mem.setUint32(addr + 4, nanHead, true);
+              this.mem.setUint32(addr, 0, true);
+              return;
+            }
+            this.mem.setFloat64(addr, v, true);
+            return;
+          }
+
+          if (v === undefined) {
+            this.mem.setFloat64(addr, 0, true);
+            return;
+          }
+
+          let id = this._ids.get(v);
+          if (id === undefined) {
+            id = this._idPool.pop();
+            if (id === undefined) {
+              id = this._values.length;
+            }
+            this._values[id] = v;
+            this._goRefCounts[id] = 0;
+            this._ids.set(v, id);
+          }
+          this._goRefCounts[id]++;
+          let typeFlag = 0;
+          switch (typeof v) {
+            case "object":
+              if (v !== null) {
+                typeFlag = 1;
+              }
+              break;
+            case "string":
+              typeFlag = 2;
+              break;
+            case "symbol":
+              typeFlag = 3;
+              break;
+            case "function":
+              typeFlag = 4;
+              break;
+          }
+          this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
+          this.mem.setUint32(addr, id, true);
+        };
+
+        const loadSlice = (addr) => {
+          const array = getInt64(addr + 0);
+          const len = getInt64(addr + 8);
+          return new Uint8Array(this._inst.exports.mem.buffer, array, len);
+        };
+
+        const loadSliceOfValues = (addr) => {
+          const array = getInt64(addr + 0);
+          const len = getInt64(addr + 8);
+          const a = new Array(len);
+          for (let i = 0; i < len; i++) {
+            a[i] = loadValue(array + i * 8);
+          }
+          return a;
+        };
+
+        const loadString = (addr) => {
+          const saddr = getInt64(addr + 0);
+          const len = getInt64(addr + 8);
+          return decoder.decode(
+            new DataView(this._inst.exports.mem.buffer, saddr, len)
+          );
+        };
+
+        const timeOrigin = Date.now() - performance.now();
+        this.importObject = {
+          _gotest: {
+            add: (a, b) => a + b,
+          },
+          gojs: {
+            // Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
+            // may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
+            // function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
+            // This changes the SP, thus we have to update the SP used by the imported function.
+
+            // func wasmExit(code int32)
+            "runtime.wasmExit": (sp) => {
+              sp >>>= 0;
+              const code = this.mem.getInt32(sp + 8, true);
+              this.exited = true;
+              delete this._inst;
+              delete this._values;
+              delete this._goRefCounts;
+              delete this._ids;
+              delete this._idPool;
+              this.exit(code);
+            },
+
+            // func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
+            "runtime.wasmWrite": (sp) => {
+              sp >>>= 0;
+              const fd = getInt64(sp + 8);
+              const p = getInt64(sp + 16);
+              const n = this.mem.getInt32(sp + 24, true);
+              fs.writeSync(
+                fd,
+                new Uint8Array(this._inst.exports.mem.buffer, p, n)
+              );
+            },
+
+            // func resetMemoryDataView()
+            "runtime.resetMemoryDataView": (sp) => {
+              this.mem = new DataView(this._inst.exports.mem.buffer);
+            },
+
+            // func nanotime1() int64
+            "runtime.nanotime1": (sp) => {
+              sp >>>= 0;
+              setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
+            },
+
+            // func walltime() (sec int64, nsec int32)
+            "runtime.walltime": (sp) => {
+              sp >>>= 0;
+              const msec = new Date().getTime();
+              setInt64(sp + 8, msec / 1000);
+              this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
+            },
+
+            // func scheduleTimeoutEvent(delay int64) int32
+            "runtime.scheduleTimeoutEvent": (sp) => {
+              sp >>>= 0;
+              const id = this._nextCallbackTimeoutID;
+              this._nextCallbackTimeoutID++;
+              this._scheduledTimeouts.set(
+                id,
+                setTimeout(() => {
+                  this._resume();
+                  while (this._scheduledTimeouts.has(id)) {
+                    // for some reason Go failed to register the timeout event, log and try again
+                    // (temporary workaround for https://github.com/golang/go/issues/28975)
+                    console.warn("scheduleTimeoutEvent: missed timeout event");
+                    this._resume();
+                  }
+                }, getInt64(sp + 8))
+              );
+              this.mem.setInt32(sp + 16, id, true);
+            },
+
+            // func clearTimeoutEvent(id int32)
+            "runtime.clearTimeoutEvent": (sp) => {
+              sp >>>= 0;
+              const id = this.mem.getInt32(sp + 8, true);
+              clearTimeout(this._scheduledTimeouts.get(id));
+              this._scheduledTimeouts.delete(id);
+            },
+
+            // func getRandomData(r []byte)
+            "runtime.getRandomData": (sp) => {
+              sp >>>= 0;
+              crypto.getRandomValues(loadSlice(sp + 8));
+            },
+
+            // func finalizeRef(v ref)
+            "syscall/js.finalizeRef": (sp) => {
+              sp >>>= 0;
+              const id = this.mem.getUint32(sp + 8, true);
+              this._goRefCounts[id]--;
+              if (this._goRefCounts[id] === 0) {
+                const v = this._values[id];
+                this._values[id] = null;
+                this._ids.delete(v);
+                this._idPool.push(id);
+              }
+            },
+
+            // func stringVal(value string) ref
+            "syscall/js.stringVal": (sp) => {
+              sp >>>= 0;
+              storeValue(sp + 24, loadString(sp + 8));
+            },
+
+            // func valueGet(v ref, p string) ref
+            "syscall/js.valueGet": (sp) => {
+              sp >>>= 0;
+              const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
+              sp = this._inst.exports.getsp() >>> 0; // see comment above
+              storeValue(sp + 32, result);
+            },
+
+            // func valueSet(v ref, p string, x ref)
+            "syscall/js.valueSet": (sp) => {
+              sp >>>= 0;
+              Reflect.set(
+                loadValue(sp + 8),
+                loadString(sp + 16),
+                loadValue(sp + 32)
+              );
+            },
+
+            // func valueDelete(v ref, p string)
+            "syscall/js.valueDelete": (sp) => {
+              sp >>>= 0;
+              Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
+            },
+
+            // func valueIndex(v ref, i int) ref
+            "syscall/js.valueIndex": (sp) => {
+              sp >>>= 0;
+              storeValue(
+                sp + 24,
+                Reflect.get(loadValue(sp + 8), getInt64(sp + 16))
+              );
+            },
+
+            // valueSetIndex(v ref, i int, x ref)
+            "syscall/js.valueSetIndex": (sp) => {
+              sp >>>= 0;
+              Reflect.set(
+                loadValue(sp + 8),
+                getInt64(sp + 16),
+                loadValue(sp + 24)
+              );
+            },
+
+            // func valueCall(v ref, m string, args []ref) (ref, bool)
+            "syscall/js.valueCall": (sp) => {
+              sp >>>= 0;
+              try {
+                const v = loadValue(sp + 8);
+                const m = Reflect.get(v, loadString(sp + 16));
+                const args = loadSliceOfValues(sp + 32);
+                const result = Reflect.apply(m, v, args);
+                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                storeValue(sp + 56, result);
+                this.mem.setUint8(sp + 64, 1);
+              } catch (err) {
+                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                storeValue(sp + 56, err);
+                this.mem.setUint8(sp + 64, 0);
+              }
+            },
+
+            // func valueInvoke(v ref, args []ref) (ref, bool)
+            "syscall/js.valueInvoke": (sp) => {
+              sp >>>= 0;
+              try {
+                const v = loadValue(sp + 8);
+                const args = loadSliceOfValues(sp + 16);
+                const result = Reflect.apply(v, undefined, args);
+                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                storeValue(sp + 40, result);
+                this.mem.setUint8(sp + 48, 1);
+              } catch (err) {
+                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                storeValue(sp + 40, err);
+                this.mem.setUint8(sp + 48, 0);
+              }
+            },
+
+            // func valueNew(v ref, args []ref) (ref, bool)
+            "syscall/js.valueNew": (sp) => {
+              sp >>>= 0;
+              try {
+                const v = loadValue(sp + 8);
+                const args = loadSliceOfValues(sp + 16);
+                const result = Reflect.construct(v, args);
+                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                storeValue(sp + 40, result);
+                this.mem.setUint8(sp + 48, 1);
+              } catch (err) {
+                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                storeValue(sp + 40, err);
+                this.mem.setUint8(sp + 48, 0);
+              }
+            },
+
+            // func valueLength(v ref) int
+            "syscall/js.valueLength": (sp) => {
+              sp >>>= 0;
+              setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
+            },
+
+            // valuePrepareString(v ref) (ref, int)
+            "syscall/js.valuePrepareString": (sp) => {
+              sp >>>= 0;
+              const str = encoder.encode(String(loadValue(sp + 8)));
+              storeValue(sp + 16, str);
+              setInt64(sp + 24, str.length);
+            },
+
+            // valueLoadString(v ref, b []byte)
+            "syscall/js.valueLoadString": (sp) => {
+              sp >>>= 0;
+              const str = loadValue(sp + 8);
+              loadSlice(sp + 16).set(str);
+            },
+
+            // func valueInstanceOf(v ref, t ref) bool
+            "syscall/js.valueInstanceOf": (sp) => {
+              sp >>>= 0;
+              this.mem.setUint8(
+                sp + 24,
+                loadValue(sp + 8) instanceof loadValue(sp + 16) ? 1 : 0
+              );
+            },
+
+            // func copyBytesToGo(dst []byte, src ref) (int, bool)
+            "syscall/js.copyBytesToGo": (sp) => {
+              sp >>>= 0;
+              const dst = loadSlice(sp + 8);
+              const src = loadValue(sp + 32);
+              if (
+                !(src instanceof Uint8Array || src instanceof Uint8ClampedArray)
+              ) {
+                this.mem.setUint8(sp + 48, 0);
+                return;
+              }
+              const toCopy = src.subarray(0, dst.length);
+              dst.set(toCopy);
+              setInt64(sp + 40, toCopy.length);
+              this.mem.setUint8(sp + 48, 1);
+            },
+
+            // func copyBytesToJS(dst ref, src []byte) (int, bool)
+            "syscall/js.copyBytesToJS": (sp) => {
+              sp >>>= 0;
+              const dst = loadValue(sp + 8);
+              const src = loadSlice(sp + 16);
+              if (
+                !(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)
+              ) {
+                this.mem.setUint8(sp + 48, 0);
+                return;
+              }
+              const toCopy = src.subarray(0, dst.length);
+              dst.set(toCopy);
+              setInt64(sp + 40, toCopy.length);
+              this.mem.setUint8(sp + 48, 1);
+            },
+
+            debug: (value) => {
+              console.log(value);
+            },
+          },
+        };
+      }
+
+      async run(instance) {
+        if (!(instance instanceof WebAssembly.Instance)) {
+          throw new Error("Go.run: WebAssembly.Instance expected");
+        }
+        this._inst = instance;
+        this.mem = new DataView(this._inst.exports.mem.buffer);
+        this._values = [
+          // JS values that Go currently has references to, indexed by reference id
+          NaN,
+          0,
+          null,
+          true,
+          false,
+          globalThis,
+          this,
+        ];
+        this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
+        this._ids = new Map([
+          // mapping from JS values to reference ids
+          [0, 1],
+          [null, 2],
+          [true, 3],
+          [false, 4],
+          [globalThis, 5],
+          [this, 6],
+        ]);
+        this._idPool = []; // unused ids that have been garbage collected
+        this.exited = false; // whether the Go program has exited
+
+        // Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
+        let offset = 4096;
+
+        const strPtr = (str) => {
+          const ptr = offset;
+          const bytes = encoder.encode(str + "\0");
+          new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
+          offset += bytes.length;
+          if (offset % 8 !== 0) {
+            offset += 8 - (offset % 8);
+          }
+          return ptr;
+        };
+
+        const argc = this.argv.length;
+
+        const argvPtrs = [];
+        this.argv.forEach((arg) => {
+          argvPtrs.push(strPtr(arg));
+        });
+        argvPtrs.push(0);
+
+        const keys = Object.keys(this.env).sort();
+        keys.forEach((key) => {
+          argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
+        });
+        argvPtrs.push(0);
+
+        const argv = offset;
+        argvPtrs.forEach((ptr) => {
+          this.mem.setUint32(offset, ptr, true);
+          this.mem.setUint32(offset + 4, 0, true);
+          offset += 8;
+        });
+
+        // The linker guarantees global data starts from at least wasmMinDataAddr.
+        // Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
+        const wasmMinDataAddr = 4096 + 8192;
+        if (offset >= wasmMinDataAddr) {
+          throw new Error(
+            "total length of command line and environment variables exceeds limit"
+          );
+        }
+
+        this._inst.exports.run(argc, argv);
+        if (this.exited) {
+          this._resolveExitPromise();
+        }
+        await this._exitPromise;
+      }
+
+      _resume() {
+        if (this.exited) {
+          throw new Error("Go program has already exited");
+        }
+        this._inst.exports.resume();
+        if (this.exited) {
+          this._resolveExitPromise();
+        }
+      }
+
+      _makeFuncWrapper(id) {
+        const go = this;
+        return function () {
+          const event = { id: id, this: this, args: arguments };
+          go._pendingEvent = event;
+          go._resume();
+          return event.result;
+        };
+      }
+    };
+  })();
+
+  ((function () {
+    try {
+      if (
+        typeof WebAssembly === "object" &&
+        typeof WebAssembly.instantiate === "function"
+      ) {
+        const module = new WebAssembly.Module(
+          Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00)
+        );
+        if (module instanceof WebAssembly.Module) {
+          return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;
+        }
+      }
+    } catch (e) {}
+    return false;
+  }))();
+
+  const go = new Go();
+
+  (function loadLocusLibrary() {
+    const module = new WebAssembly.Module(wasm);
+    const instance = new WebAssembly.Instance(module, go.importObject);
+    go.run(instance);
+  })();
+
+  class LocusLib {
+      static callWasm(wasmCmd, wasmParams) {
+          if (Array.isArray(wasmParams)) {
+              wasmParams = wasmParams[0];
+          }
+          // @ts-ignore
+          if (typeof globalThis["CallLclib"] !== "function")
               return;
-            }
-            const n = this.writeSync(fd, buf);
-            callback(null, n);
-          },
-          chmod(path, mode, callback) {
-            callback(enosys());
-          },
-          chown(path, uid, gid, callback) {
-            callback(enosys());
-          },
-          close(fd, callback) {
-            callback(enosys());
-          },
-          fchmod(fd, mode, callback) {
-            callback(enosys());
-          },
-          fchown(fd, uid, gid, callback) {
-            callback(enosys());
-          },
-          fstat(fd, callback) {
-            callback(enosys());
-          },
-          fsync(fd, callback) {
-            callback(null);
-          },
-          ftruncate(fd, length, callback) {
-            callback(enosys());
-          },
-          lchown(path, uid, gid, callback) {
-            callback(enosys());
-          },
-          link(path, link, callback) {
-            callback(enosys());
-          },
-          lstat(path, callback) {
-            callback(enosys());
-          },
-          mkdir(path, perm, callback) {
-            callback(enosys());
-          },
-          open(path, flags, mode, callback) {
-            callback(enosys());
-          },
-          read(fd, buffer, offset, length, position, callback) {
-            callback(enosys());
-          },
-          readdir(path, callback) {
-            callback(enosys());
-          },
-          readlink(path, callback) {
-            callback(enosys());
-          },
-          rename(from, to, callback) {
-            callback(enosys());
-          },
-          rmdir(path, callback) {
-            callback(enosys());
-          },
-          stat(path, callback) {
-            callback(enosys());
-          },
-          symlink(path, link, callback) {
-            callback(enosys());
-          },
-          truncate(path, length, callback) {
-            callback(enosys());
-          },
-          unlink(path, callback) {
-            callback(enosys());
-          },
-          utimes(path, atime, mtime, callback) {
-            callback(enosys());
+          // @ts-ignore
+          const resultString = globalThis["CallLclib"](wasmCmd, JSON.stringify(wasmParams));
+          const result = JSON.parse(resultString);
+          if (result.Error && result.Error.Code != 0) {
+              const error = Object.assign(Object.assign({}, result.Error), { message: result.Error.Message });
+              delete error.Message;
+              return error;
+          }
+          else {
+              return result.Result;
           }
-        };
       }
-
-      // if (!globalThis.process) {
-      //   globalThis.process = {
-      //     getuid() {
-      //       return -1;
-      //     },
-      //     getgid() {
-      //       return -1;
-      //     },
-      //     geteuid() {
-      //       return -1;
-      //     },
-      //     getegid() {
-      //       return -1;
-      //     },
-      //     getgroups() {
-      //       throw enosys();
-      //     },
-      //     pid: -1,
-      //     ppid: -1,
-      //     umask() {
-      //       throw enosys();
-      //     },
-      //     cwd() {
-      //       throw enosys();
-      //     },
-      //     chdir() {
-      //       throw enosys();
-      //     }
-      //   };
-      // }
-
-      if (!globalThis.crypto) {
-        throw new Error('globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)');
+      //=================================================================================
+      static GetLibInfo() {
+          return wasmJson;
       }
-
-      if (!globalThis.performance) {
-        throw new Error('globalThis.performance is not available, polyfill required (performance.now only)');
+      static GetLibraryVersions() {
+          return LocusLib.callWasm("GetLibraryVersions", {});
       }
-
-      if (!globalThis.TextEncoder) {
-        throw new Error('globalThis.TextEncoder is not available, polyfill required');
+      static CreateAccountAndKeystore(passwordMaster, passwordNormal, mkeyAlgoNormal, nkeyAlgoNormal) {
+          return LocusLib.callWasm("CreateAccountAndKeystore", {
+              passwordMaster,
+              passwordNormal,
+              mkeyAlgoNormal,
+              nkeyAlgoNormal,
+          });
       }
-
-      if (!globalThis.TextDecoder) {
-        throw new Error('globalThis.TextDecoder is not available, polyfill required');
+      static CreateNormalKey(addrStr, keyAlgo) {
+          return LocusLib.callWasm("CreateNormalKey", { addrStr, keyAlgo });
       }
-
-      const encoder = new TextEncoder('utf-8');
-      const decoder = new TextDecoder('utf-8');
-
-      globalThis.Go = class {
-        constructor() {
-          this.argv = ['js'];
-          this.env = {};
-          this.exit = code => {
-            if (code !== 0) {
-              console.warn('exit code:', code);
-            }
-          };
-          this._exitPromise = new Promise(resolve => {
-            this._resolveExitPromise = resolve;
+      static CreateMasterKeystore(AddrStr, Password, MskStr, MpkStr) {
+          return LocusLib.callWasm("CreateMasterKeystore", {
+              AddrStr,
+              Password,
+              MskStr,
+              MpkStr,
           });
-          this._pendingEvent = null;
-          this._scheduledTimeouts = new Map();
-          this._nextCallbackTimeoutID = 1;
-
-          const setInt64 = (addr, v) => {
-            this.mem.setUint32(addr + 0, v, true);
-            this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
-          };
-
-          const getInt64 = addr => {
-            const low = this.mem.getUint32(addr + 0, true);
-            const high = this.mem.getInt32(addr + 4, true);
-            return low + high * 4294967296;
-          };
-
-          const loadValue = addr => {
-            const f = this.mem.getFloat64(addr, true);
-            if (f === 0) {
-              return undefined;
-            }
-            if (!isNaN(f)) {
-              return f;
-            }
-
-            const id = this.mem.getUint32(addr, true);
-            return this._values[id];
-          };
-
-          const storeValue = (addr, v) => {
-            const nanHead = 0x7ff80000;
-
-            if (typeof v === 'number' && v !== 0) {
-              if (isNaN(v)) {
-                this.mem.setUint32(addr + 4, nanHead, true);
-                this.mem.setUint32(addr, 0, true);
-                return;
-              }
-              this.mem.setFloat64(addr, v, true);
-              return;
-            }
-
-            if (v === undefined) {
-              this.mem.setFloat64(addr, 0, true);
-              return;
-            }
-
-            let id = this._ids.get(v);
-            if (id === undefined) {
-              id = this._idPool.pop();
-              if (id === undefined) {
-                id = this._values.length;
-              }
-              this._values[id] = v;
-              this._goRefCounts[id] = 0;
-              this._ids.set(v, id);
-            }
-            this._goRefCounts[id]++;
-            let typeFlag = 0;
-            switch (typeof v) {
-              case 'object':
-                if (v !== null) {
-                  typeFlag = 1;
-                }
-                break;
-              case 'string':
-                typeFlag = 2;
-                break;
-              case 'symbol':
-                typeFlag = 3;
-                break;
-              case 'function':
-                typeFlag = 4;
-                break;
-            }
-            this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
-            this.mem.setUint32(addr, id, true);
-          };
-
-          const loadSlice = addr => {
-            const array = getInt64(addr + 0);
-            const len = getInt64(addr + 8);
-            return new Uint8Array(this._inst.exports.mem.buffer, array, len);
-          };
-
-          const loadSliceOfValues = addr => {
-            const array = getInt64(addr + 0);
-            const len = getInt64(addr + 8);
-            const a = new Array(len);
-            for (let i = 0; i < len; i++) {
-              a[i] = loadValue(array + i * 8);
-            }
-            return a;
-          };
-
-          const loadString = addr => {
-            const saddr = getInt64(addr + 0);
-            const len = getInt64(addr + 8);
-            return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
-          };
-
-          const timeOrigin = Date.now() - performance.now();
-          this.importObject = {
-            _gotest: {
-              add: (a, b) => a + b
-            },
-            gojs: {
-              // Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
-              // may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
-              // function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
-              // This changes the SP, thus we have to update the SP used by the imported function.
-
-              // func wasmExit(code int32)
-              'runtime.wasmExit': sp => {
-                sp >>>= 0;
-                const code = this.mem.getInt32(sp + 8, true);
-                this.exited = true;
-                delete this._inst;
-                delete this._values;
-                delete this._goRefCounts;
-                delete this._ids;
-                delete this._idPool;
-                this.exit(code);
-              },
-
-              // func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
-              'runtime.wasmWrite': sp => {
-                sp >>>= 0;
-                const fd = getInt64(sp + 8);
-                const p = getInt64(sp + 16);
-                const n = this.mem.getInt32(sp + 24, true);
-                fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
-              },
-
-              // func resetMemoryDataView()
-              'runtime.resetMemoryDataView': sp => {
-                this.mem = new DataView(this._inst.exports.mem.buffer);
-              },
-
-              // func nanotime1() int64
-              'runtime.nanotime1': sp => {
-                sp >>>= 0;
-                setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
-              },
-
-              // func walltime() (sec int64, nsec int32)
-              'runtime.walltime': sp => {
-                sp >>>= 0;
-                const msec = new Date().getTime();
-                setInt64(sp + 8, msec / 1000);
-                this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
-              },
-
-              // func scheduleTimeoutEvent(delay int64) int32
-              'runtime.scheduleTimeoutEvent': sp => {
-                sp >>>= 0;
-                const id = this._nextCallbackTimeoutID;
-                this._nextCallbackTimeoutID++;
-                this._scheduledTimeouts.set(
-                  id,
-                  setTimeout(() => {
-                    this._resume();
-                    while (this._scheduledTimeouts.has(id)) {
-                      // for some reason Go failed to register the timeout event, log and try again
-                      // (temporary workaround for https://github.com/golang/go/issues/28975)
-                      console.warn('scheduleTimeoutEvent: missed timeout event');
-                      this._resume();
-                    }
-                  }, getInt64(sp + 8))
-                );
-                this.mem.setInt32(sp + 16, id, true);
-              },
-
-              // func clearTimeoutEvent(id int32)
-              'runtime.clearTimeoutEvent': sp => {
-                sp >>>= 0;
-                const id = this.mem.getInt32(sp + 8, true);
-                clearTimeout(this._scheduledTimeouts.get(id));
-                this._scheduledTimeouts.delete(id);
-              },
-
-              // func getRandomData(r []byte)
-              'runtime.getRandomData': sp => {
-                sp >>>= 0;
-                crypto.getRandomValues(loadSlice(sp + 8));
-              },
-
-              // func finalizeRef(v ref)
-              'syscall/js.finalizeRef': sp => {
-                sp >>>= 0;
-                const id = this.mem.getUint32(sp + 8, true);
-                this._goRefCounts[id]--;
-                if (this._goRefCounts[id] === 0) {
-                  const v = this._values[id];
-                  this._values[id] = null;
-                  this._ids.delete(v);
-                  this._idPool.push(id);
-                }
-              },
-
-              // func stringVal(value string) ref
-              'syscall/js.stringVal': sp => {
-                sp >>>= 0;
-                storeValue(sp + 24, loadString(sp + 8));
-              },
-
-              // func valueGet(v ref, p string) ref
-              'syscall/js.valueGet': sp => {
-                sp >>>= 0;
-                const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
-                sp = this._inst.exports.getsp() >>> 0; // see comment above
-                storeValue(sp + 32, result);
-              },
-
-              // func valueSet(v ref, p string, x ref)
-              'syscall/js.valueSet': sp => {
-                sp >>>= 0;
-                Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
-              },
-
-              // func valueDelete(v ref, p string)
-              'syscall/js.valueDelete': sp => {
-                sp >>>= 0;
-                Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
-              },
-
-              // func valueIndex(v ref, i int) ref
-              'syscall/js.valueIndex': sp => {
-                sp >>>= 0;
-                storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
-              },
-
-              // valueSetIndex(v ref, i int, x ref)
-              'syscall/js.valueSetIndex': sp => {
-                sp >>>= 0;
-                Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
-              },
-
-              // func valueCall(v ref, m string, args []ref) (ref, bool)
-              'syscall/js.valueCall': sp => {
-                sp >>>= 0;
-                try {
-                  const v = loadValue(sp + 8);
-                  const m = Reflect.get(v, loadString(sp + 16));
-                  const args = loadSliceOfValues(sp + 32);
-                  const result = Reflect.apply(m, v, args);
-                  sp = this._inst.exports.getsp() >>> 0; // see comment above
-                  storeValue(sp + 56, result);
-                  this.mem.setUint8(sp + 64, 1);
-                } catch (err) {
-                  sp = this._inst.exports.getsp() >>> 0; // see comment above
-                  storeValue(sp + 56, err);
-                  this.mem.setUint8(sp + 64, 0);
-                }
-              },
-
-              // func valueInvoke(v ref, args []ref) (ref, bool)
-              'syscall/js.valueInvoke': sp => {
-                sp >>>= 0;
-                try {
-                  const v = loadValue(sp + 8);
-                  const args = loadSliceOfValues(sp + 16);
-                  const result = Reflect.apply(v, undefined, args);
-                  sp = this._inst.exports.getsp() >>> 0; // see comment above
-                  storeValue(sp + 40, result);
-                  this.mem.setUint8(sp + 48, 1);
-                } catch (err) {
-                  sp = this._inst.exports.getsp() >>> 0; // see comment above
-                  storeValue(sp + 40, err);
-                  this.mem.setUint8(sp + 48, 0);
-                }
-              },
-
-              // func valueNew(v ref, args []ref) (ref, bool)
-              'syscall/js.valueNew': sp => {
-                sp >>>= 0;
-                try {
-                  const v = loadValue(sp + 8);
-                  const args = loadSliceOfValues(sp + 16);
-                  const result = Reflect.construct(v, args);
-                  sp = this._inst.exports.getsp() >>> 0; // see comment above
-                  storeValue(sp + 40, result);
-                  this.mem.setUint8(sp + 48, 1);
-                } catch (err) {
-                  sp = this._inst.exports.getsp() >>> 0; // see comment above
-                  storeValue(sp + 40, err);
-                  this.mem.setUint8(sp + 48, 0);
-                }
-              },
-
-              // func valueLength(v ref) int
-              'syscall/js.valueLength': sp => {
-                sp >>>= 0;
-                setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
-              },
-
-              // valuePrepareString(v ref) (ref, int)
-              'syscall/js.valuePrepareString': sp => {
-                sp >>>= 0;
-                const str = encoder.encode(String(loadValue(sp + 8)));
-                storeValue(sp + 16, str);
-                setInt64(sp + 24, str.length);
-              },
-
-              // valueLoadString(v ref, b []byte)
-              'syscall/js.valueLoadString': sp => {
-                sp >>>= 0;
-                const str = loadValue(sp + 8);
-                loadSlice(sp + 16).set(str);
-              },
-
-              // func valueInstanceOf(v ref, t ref) bool
-              'syscall/js.valueInstanceOf': sp => {
-                sp >>>= 0;
-                this.mem.setUint8(sp + 24, loadValue(sp + 8) instanceof loadValue(sp + 16) ? 1 : 0);
-              },
-
-              // func copyBytesToGo(dst []byte, src ref) (int, bool)
-              'syscall/js.copyBytesToGo': sp => {
-                sp >>>= 0;
-                const dst = loadSlice(sp + 8);
-                const src = loadValue(sp + 32);
-                if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
-                  this.mem.setUint8(sp + 48, 0);
-                  return;
-                }
-                const toCopy = src.subarray(0, dst.length);
-                dst.set(toCopy);
-                setInt64(sp + 40, toCopy.length);
-                this.mem.setUint8(sp + 48, 1);
-              },
-
-              // func copyBytesToJS(dst ref, src []byte) (int, bool)
-              'syscall/js.copyBytesToJS': sp => {
-                sp >>>= 0;
-                const dst = loadValue(sp + 8);
-                const src = loadSlice(sp + 16);
-                if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
-                  this.mem.setUint8(sp + 48, 0);
-                  return;
-                }
-                const toCopy = src.subarray(0, dst.length);
-                dst.set(toCopy);
-                setInt64(sp + 40, toCopy.length);
-                this.mem.setUint8(sp + 48, 1);
-              },
-
-              debug: value => {
-                console.log(value);
-              }
-            }
-          };
-        }
-
-        async run(instance) {
-          if (!(instance instanceof WebAssembly.Instance)) {
-            throw new Error('Go.run: WebAssembly.Instance expected');
-          }
-          this._inst = instance;
-          this.mem = new DataView(this._inst.exports.mem.buffer);
-          this._values = [
-            // JS values that Go currently has references to, indexed by reference id
-            NaN,
-            0,
-            null,
-            true,
-            false,
-            globalThis,
-            this
-          ];
-          this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
-          this._ids = new Map([
-            // mapping from JS values to reference ids
-            [0, 1],
-            [null, 2],
-            [true, 3],
-            [false, 4],
-            [globalThis, 5],
-            [this, 6]
-          ]);
-          this._idPool = []; // unused ids that have been garbage collected
-          this.exited = false; // whether the Go program has exited
-
-          // Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
-          let offset = 4096;
-
-          const strPtr = str => {
-            const ptr = offset;
-            const bytes = encoder.encode(str + '\0');
-            new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
-            offset += bytes.length;
-            if (offset % 8 !== 0) {
-              offset += 8 - (offset % 8);
-            }
-            return ptr;
-          };
-
-          const argc = this.argv.length;
-
-          const argvPtrs = [];
-          this.argv.forEach(arg => {
-            argvPtrs.push(strPtr(arg));
-          });
-          argvPtrs.push(0);
-
-          const keys = Object.keys(this.env).sort();
-          keys.forEach(key => {
-            argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
+      }
+      static CreateNormalKeystore(AddrStr, Password, NskStr, NpkStr, MpkStr = "", KeySign = "") {
+          return LocusLib.callWasm("CreateNormalKeystore", {
+              AddrStr,
+              Password,
+              NskStr,
+              NpkStr,
+              MpkStr,
+              KeySign,
           });
-          argvPtrs.push(0);
-
-          const argv = offset;
-          argvPtrs.forEach(ptr => {
-            this.mem.setUint32(offset, ptr, true);
-            this.mem.setUint32(offset + 4, 0, true);
-            offset += 8;
+      }
+      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);
+      }
+      static GenerateMnemonic(entropyBit = 256) {
+          return LocusLib.callWasm("GenerateMnemonic", { entropyBit });
+      }
+      static DeriveKeysFromMnemonic(mnemonic, path) {
+          return LocusLib.callWasm("DeriveKeysFromMnemonic", { mnemonic, path });
+      }
+  }
+  LocusLib.sleep = (ms) => new Promise((resolve) => setTimeout(() => resolve(true), ms));
 
-          // The linker guarantees global data starts from at least wasmMinDataAddr.
-          // Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
-          const wasmMinDataAddr = 4096 + 8192;
-          if (offset >= wasmMinDataAddr) {
-            throw new Error('total length of command line and environment variables exceeds limit');
-          }
-
-          this._inst.exports.run(argc, argv);
-          if (this.exited) {
-            this._resolveExitPromise();
-          }
-          await this._exitPromise;
-        }
-
-        _resume() {
-          if (this.exited) {
-            throw new Error('Go program has already exited');
-          }
-          this._inst.exports.resume();
-          if (this.exited) {
-            this._resolveExitPromise();
-          }
-        }
-
-        _makeFuncWrapper(id) {
-          const go = this;
-          return function () {
-            const event = { id: id, this: this, args: arguments };
-            go._pendingEvent = event;
-            go._resume();
-            return event.result;
-          };
-        }
-      };
-    })();
-
-    ((function () {
-      try {
-        if (typeof WebAssembly === 'object' && typeof WebAssembly.instantiate === 'function') {
-          const module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
-          if (module instanceof WebAssembly.Module) {
-            return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;
-          }
-        }
-      } catch (e) {}
-      return false;
-    }))();
-
-    const go = new Go();
-
-    function loadLocusLibrary() {
-      return new Promise((resolve, reject) => {    
-        WebAssembly.instantiate(wasm, go.importObject)
-          .then(result => {
-            go.run(result.instance);
-            resolve();
-          })
-          .catch(err => {
-            console.error('err:', err);
-            reject();
-          });      
-      });
-    }
-
-    loadLocusLibrary().then((res) => {
-    });
-    class LocusLib {
-        static callWasm(wasmCmd, wasmParams) {
-            return new Promise((resolve, reject) => __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) {
-                    const error = Object.assign(Object.assign({}, result.Error), { message: result.Error.Message });
-                    delete error.Message;
-                    reject(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;
+  exports.LocusLib = LocusLib;
 
 }));