@pioneer-platform/pioneer-react 0.2.42 → 0.2.43

package/dist/{index_70cc14bd.js → index_96d5aad1.js}

@@ -1,7 +1,6 @@
-import { b as build$3 } from "./index_2143ad7f.js";
-import { b as buffer, c as commonjsGlobal, r as require$$0, o as pbkdf2$1, k as sha512$1, s as sha256$1, _ as _assert, u as utils$1, t as _u64, d as getAugmentedNamespace, p as process, v as _sha2 } from "./index_015b6eba.js";
-import { a as bnExports, b as build$4 } from "./index_e525ec6b.js";
-import { e as elliptic } from "./index_13b1e6a1.js";
+import { c as commonjsGlobal, a as base64Js, d as bech32$2, f as buffer, _ as _assert, u as utils$1, h as _sha2, r as require$$0, s as sha256$1, j as getAugmentedNamespace, p as process } from "./index_d77fc157.js";
+import { b as bnExports } from "./index_7640e861.js";
+import { e as elliptic } from "./index_65017d87.js";
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {
     const e = m[i];
@@ -21,11 +20,690 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-var build$2 = {};
+var build$4 = {};
+var decimal = {};
+var __importDefault$3 = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
+  return mod && mod.__esModule ? mod : { "default": mod };
+};
+Object.defineProperty(decimal, "__esModule", { value: true });
+decimal.Decimal = void 0;
+const bn_js_1$2 = __importDefault$3(bnExports);
+const maxFractionalDigits = 100;
+class Decimal {
+  static fromUserInput(input, fractionalDigits) {
+    Decimal.verifyFractionalDigits(fractionalDigits);
+    const badCharacter = input.match(/[^0-9.]/);
+    if (badCharacter) {
+      throw new Error(`Invalid character at position ${badCharacter.index + 1}`);
+    }
+    let whole;
+    let fractional;
+    if (input === "") {
+      whole = "0";
+      fractional = "";
+    } else if (input.search(/\./) === -1) {
+      whole = input;
+      fractional = "";
+    } else {
+      const parts = input.split(".");
+      switch (parts.length) {
+        case 0:
+        case 1:
+          throw new Error("Fewer than two elements in split result. This must not happen here.");
+        case 2:
+          if (!parts[1])
+            throw new Error("Fractional part missing");
+          whole = parts[0];
+          fractional = parts[1].replace(/0+$/, "");
+          break;
+        default:
+          throw new Error("More than one separator found");
+      }
+    }
+    if (fractional.length > fractionalDigits) {
+      throw new Error("Got more fractional digits than supported");
+    }
+    const quantity = `${whole}${fractional.padEnd(fractionalDigits, "0")}`;
+    return new Decimal(quantity, fractionalDigits);
+  }
+  static fromAtomics(atomics, fractionalDigits) {
+    Decimal.verifyFractionalDigits(fractionalDigits);
+    return new Decimal(atomics, fractionalDigits);
+  }
+  /**
+   * Creates a Decimal with value 0.0 and the given number of fractial digits.
+   *
+   * Fractional digits are not relevant for the value but needed to be able
+   * to perform arithmetic operations with other decimals.
+   */
+  static zero(fractionalDigits) {
+    Decimal.verifyFractionalDigits(fractionalDigits);
+    return new Decimal("0", fractionalDigits);
+  }
+  /**
+   * Creates a Decimal with value 1.0 and the given number of fractial digits.
+   *
+   * Fractional digits are not relevant for the value but needed to be able
+   * to perform arithmetic operations with other decimals.
+   */
+  static one(fractionalDigits) {
+    Decimal.verifyFractionalDigits(fractionalDigits);
+    return new Decimal("1" + "0".repeat(fractionalDigits), fractionalDigits);
+  }
+  static verifyFractionalDigits(fractionalDigits) {
+    if (!Number.isInteger(fractionalDigits))
+      throw new Error("Fractional digits is not an integer");
+    if (fractionalDigits < 0)
+      throw new Error("Fractional digits must not be negative");
+    if (fractionalDigits > maxFractionalDigits) {
+      throw new Error(`Fractional digits must not exceed ${maxFractionalDigits}`);
+    }
+  }
+  static compare(a, b) {
+    if (a.fractionalDigits !== b.fractionalDigits)
+      throw new Error("Fractional digits do not match");
+    return a.data.atomics.cmp(new bn_js_1$2.default(b.atomics));
+  }
+  get atomics() {
+    return this.data.atomics.toString();
+  }
+  get fractionalDigits() {
+    return this.data.fractionalDigits;
+  }
+  constructor(atomics, fractionalDigits) {
+    if (!atomics.match(/^[0-9]+$/)) {
+      throw new Error("Invalid string format. Only non-negative integers in decimal representation supported.");
+    }
+    this.data = {
+      atomics: new bn_js_1$2.default(atomics),
+      fractionalDigits
+    };
+  }
+  /** Creates a new instance with the same value */
+  clone() {
+    return new Decimal(this.atomics, this.fractionalDigits);
+  }
+  /** Returns the greatest decimal <= this which has no fractional part (rounding down) */
+  floor() {
+    const factor = new bn_js_1$2.default(10).pow(new bn_js_1$2.default(this.data.fractionalDigits));
+    const whole = this.data.atomics.div(factor);
+    const fractional = this.data.atomics.mod(factor);
+    if (fractional.isZero()) {
+      return this.clone();
+    } else {
+      return Decimal.fromAtomics(whole.mul(factor).toString(), this.fractionalDigits);
+    }
+  }
+  /** Returns the smallest decimal >= this which has no fractional part (rounding up) */
+  ceil() {
+    const factor = new bn_js_1$2.default(10).pow(new bn_js_1$2.default(this.data.fractionalDigits));
+    const whole = this.data.atomics.div(factor);
+    const fractional = this.data.atomics.mod(factor);
+    if (fractional.isZero()) {
+      return this.clone();
+    } else {
+      return Decimal.fromAtomics(whole.addn(1).mul(factor).toString(), this.fractionalDigits);
+    }
+  }
+  toString() {
+    const factor = new bn_js_1$2.default(10).pow(new bn_js_1$2.default(this.data.fractionalDigits));
+    const whole = this.data.atomics.div(factor);
+    const fractional = this.data.atomics.mod(factor);
+    if (fractional.isZero()) {
+      return whole.toString();
+    } else {
+      const fullFractionalPart = fractional.toString().padStart(this.data.fractionalDigits, "0");
+      const trimmedFractionalPart = fullFractionalPart.replace(/0+$/, "");
+      return `${whole.toString()}.${trimmedFractionalPart}`;
+    }
+  }
+  /**
+   * Returns an approximation as a float type. Only use this if no
+   * exact calculation is required.
+   */
+  toFloatApproximation() {
+    const out = Number(this.toString());
+    if (Number.isNaN(out))
+      throw new Error("Conversion to number failed");
+    return out;
+  }
+  /**
+   * a.plus(b) returns a+b.
+   *
+   * Both values need to have the same fractional digits.
+   */
+  plus(b) {
+    if (this.fractionalDigits !== b.fractionalDigits)
+      throw new Error("Fractional digits do not match");
+    const sum = this.data.atomics.add(new bn_js_1$2.default(b.atomics));
+    return new Decimal(sum.toString(), this.fractionalDigits);
+  }
+  /**
+   * a.minus(b) returns a-b.
+   *
+   * Both values need to have the same fractional digits.
+   * The resulting difference needs to be non-negative.
+   */
+  minus(b) {
+    if (this.fractionalDigits !== b.fractionalDigits)
+      throw new Error("Fractional digits do not match");
+    const difference = this.data.atomics.sub(new bn_js_1$2.default(b.atomics));
+    if (difference.ltn(0))
+      throw new Error("Difference must not be negative");
+    return new Decimal(difference.toString(), this.fractionalDigits);
+  }
+  /**
+   * a.multiply(b) returns a*b.
+   *
+   * We only allow multiplication by unsigned integers to avoid rounding errors.
+   */
+  multiply(b) {
+    const product = this.data.atomics.mul(new bn_js_1$2.default(b.toString()));
+    return new Decimal(product.toString(), this.fractionalDigits);
+  }
+  equals(b) {
+    return Decimal.compare(this, b) === 0;
+  }
+  isLessThan(b) {
+    return Decimal.compare(this, b) < 0;
+  }
+  isLessThanOrEqual(b) {
+    return Decimal.compare(this, b) <= 0;
+  }
+  isGreaterThan(b) {
+    return Decimal.compare(this, b) > 0;
+  }
+  isGreaterThanOrEqual(b) {
+    return Decimal.compare(this, b) >= 0;
+  }
+}
+decimal.Decimal = Decimal;
+var integers = {};
+var __importDefault$2 = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
+  return mod && mod.__esModule ? mod : { "default": mod };
+};
+Object.defineProperty(integers, "__esModule", { value: true });
+integers.Uint64 = integers.Uint53 = integers.Int53 = integers.Uint32 = void 0;
+const bn_js_1$1 = __importDefault$2(bnExports);
+const uint64MaxValue = new bn_js_1$1.default("18446744073709551615", 10, "be");
+class Uint32 {
+  /** @deprecated use Uint32.fromBytes */
+  static fromBigEndianBytes(bytes) {
+    return Uint32.fromBytes(bytes);
+  }
+  /**
+   * Creates a Uint32 from a fixed length byte array.
+   *
+   * @param bytes a list of exactly 4 bytes
+   * @param endianess defaults to big endian
+   */
+  static fromBytes(bytes, endianess = "be") {
+    if (bytes.length !== 4) {
+      throw new Error("Invalid input length. Expected 4 bytes.");
+    }
+    for (let i = 0; i < bytes.length; ++i) {
+      if (!Number.isInteger(bytes[i]) || bytes[i] > 255 || bytes[i] < 0) {
+        throw new Error("Invalid value in byte. Found: " + bytes[i]);
+      }
+    }
+    const beBytes = endianess === "be" ? bytes : Array.from(bytes).reverse();
+    return new Uint32(beBytes[0] * 2 ** 24 + beBytes[1] * 2 ** 16 + beBytes[2] * 2 ** 8 + beBytes[3]);
+  }
+  static fromString(str) {
+    if (!str.match(/^[0-9]+$/)) {
+      throw new Error("Invalid string format");
+    }
+    return new Uint32(Number.parseInt(str, 10));
+  }
+  constructor(input) {
+    if (Number.isNaN(input)) {
+      throw new Error("Input is not a number");
+    }
+    if (!Number.isInteger(input)) {
+      throw new Error("Input is not an integer");
+    }
+    if (input < 0 || input > 4294967295) {
+      throw new Error("Input not in uint32 range: " + input.toString());
+    }
+    this.data = input;
+  }
+  toBytesBigEndian() {
+    return new Uint8Array([
+      Math.floor(this.data / 2 ** 24) & 255,
+      Math.floor(this.data / 2 ** 16) & 255,
+      Math.floor(this.data / 2 ** 8) & 255,
+      Math.floor(this.data / 2 ** 0) & 255
+    ]);
+  }
+  toBytesLittleEndian() {
+    return new Uint8Array([
+      Math.floor(this.data / 2 ** 0) & 255,
+      Math.floor(this.data / 2 ** 8) & 255,
+      Math.floor(this.data / 2 ** 16) & 255,
+      Math.floor(this.data / 2 ** 24) & 255
+    ]);
+  }
+  toNumber() {
+    return this.data;
+  }
+  toBigInt() {
+    return BigInt(this.toNumber());
+  }
+  toString() {
+    return this.data.toString();
+  }
+}
+integers.Uint32 = Uint32;
+class Int53 {
+  static fromString(str) {
+    if (!str.match(/^-?[0-9]+$/)) {
+      throw new Error("Invalid string format");
+    }
+    return new Int53(Number.parseInt(str, 10));
+  }
+  constructor(input) {
+    if (Number.isNaN(input)) {
+      throw new Error("Input is not a number");
+    }
+    if (!Number.isInteger(input)) {
+      throw new Error("Input is not an integer");
+    }
+    if (input < Number.MIN_SAFE_INTEGER || input > Number.MAX_SAFE_INTEGER) {
+      throw new Error("Input not in int53 range: " + input.toString());
+    }
+    this.data = input;
+  }
+  toNumber() {
+    return this.data;
+  }
+  toBigInt() {
+    return BigInt(this.toNumber());
+  }
+  toString() {
+    return this.data.toString();
+  }
+}
+integers.Int53 = Int53;
+class Uint53 {
+  static fromString(str) {
+    const signed = Int53.fromString(str);
+    return new Uint53(signed.toNumber());
+  }
+  constructor(input) {
+    const signed = new Int53(input);
+    if (signed.toNumber() < 0) {
+      throw new Error("Input is negative");
+    }
+    this.data = signed;
+  }
+  toNumber() {
+    return this.data.toNumber();
+  }
+  toBigInt() {
+    return BigInt(this.toNumber());
+  }
+  toString() {
+    return this.data.toString();
+  }
+}
+integers.Uint53 = Uint53;
+class Uint64 {
+  /** @deprecated use Uint64.fromBytes */
+  static fromBytesBigEndian(bytes) {
+    return Uint64.fromBytes(bytes);
+  }
+  /**
+   * Creates a Uint64 from a fixed length byte array.
+   *
+   * @param bytes a list of exactly 8 bytes
+   * @param endianess defaults to big endian
+   */
+  static fromBytes(bytes, endianess = "be") {
+    if (bytes.length !== 8) {
+      throw new Error("Invalid input length. Expected 8 bytes.");
+    }
+    for (let i = 0; i < bytes.length; ++i) {
+      if (!Number.isInteger(bytes[i]) || bytes[i] > 255 || bytes[i] < 0) {
+        throw new Error("Invalid value in byte. Found: " + bytes[i]);
+      }
+    }
+    const beBytes = endianess === "be" ? Array.from(bytes) : Array.from(bytes).reverse();
+    return new Uint64(new bn_js_1$1.default(beBytes));
+  }
+  static fromString(str) {
+    if (!str.match(/^[0-9]+$/)) {
+      throw new Error("Invalid string format");
+    }
+    return new Uint64(new bn_js_1$1.default(str, 10, "be"));
+  }
+  static fromNumber(input) {
+    if (Number.isNaN(input)) {
+      throw new Error("Input is not a number");
+    }
+    if (!Number.isInteger(input)) {
+      throw new Error("Input is not an integer");
+    }
+    let bigint;
+    try {
+      bigint = new bn_js_1$1.default(input);
+    } catch {
+      throw new Error("Input is not a safe integer");
+    }
+    return new Uint64(bigint);
+  }
+  constructor(data) {
+    if (data.isNeg()) {
+      throw new Error("Input is negative");
+    }
+    if (data.gt(uint64MaxValue)) {
+      throw new Error("Input exceeds uint64 range");
+    }
+    this.data = data;
+  }
+  toBytesBigEndian() {
+    return Uint8Array.from(this.data.toArray("be", 8));
+  }
+  toBytesLittleEndian() {
+    return Uint8Array.from(this.data.toArray("le", 8));
+  }
+  toString() {
+    return this.data.toString(10);
+  }
+  toBigInt() {
+    return BigInt(this.toString());
+  }
+  toNumber() {
+    return this.data.toNumber();
+  }
+}
+integers.Uint64 = Uint64;
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Uint64 = exports.Uint53 = exports.Uint32 = exports.Int53 = exports.Decimal = void 0;
+  var decimal_1 = decimal;
+  Object.defineProperty(exports, "Decimal", { enumerable: true, get: function() {
+    return decimal_1.Decimal;
+  } });
+  var integers_1 = integers;
+  Object.defineProperty(exports, "Int53", { enumerable: true, get: function() {
+    return integers_1.Int53;
+  } });
+  Object.defineProperty(exports, "Uint32", { enumerable: true, get: function() {
+    return integers_1.Uint32;
+  } });
+  Object.defineProperty(exports, "Uint53", { enumerable: true, get: function() {
+    return integers_1.Uint53;
+  } });
+  Object.defineProperty(exports, "Uint64", { enumerable: true, get: function() {
+    return integers_1.Uint64;
+  } });
+})(build$4);
+var build$3 = {};
 var addresses = {};
-var build$1 = {};
+var build$2 = {};
 var bip39 = {};
-var pbkdf2 = {};
+var build$1 = {};
+var ascii = {};
+Object.defineProperty(ascii, "__esModule", { value: true });
+ascii.fromAscii = ascii.toAscii = void 0;
+function toAscii(input) {
+  const toNums = (str) => str.split("").map((x) => {
+    const charCode = x.charCodeAt(0);
+    if (charCode < 32 || charCode > 126) {
+      throw new Error("Cannot encode character that is out of printable ASCII range: " + charCode);
+    }
+    return charCode;
+  });
+  return Uint8Array.from(toNums(input));
+}
+ascii.toAscii = toAscii;
+function fromAscii(data) {
+  const fromNums = (listOfNumbers) => listOfNumbers.map((x) => {
+    if (x < 32 || x > 126) {
+      throw new Error("Cannot decode character that is out of printable ASCII range: " + x);
+    }
+    return String.fromCharCode(x);
+  });
+  return fromNums(Array.from(data)).join("");
+}
+ascii.fromAscii = fromAscii;
+var base64 = {};
+var __createBinding$2 = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+  if (k2 === void 0)
+    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 === void 0)
+    k2 = k;
+  o[k2] = m[k];
+});
+var __setModuleDefault$2 = commonjsGlobal && commonjsGlobal.__setModuleDefault || (Object.create ? function(o, v) {
+  Object.defineProperty(o, "default", { enumerable: true, value: v });
+} : function(o, v) {
+  o["default"] = v;
+});
+var __importStar$2 = commonjsGlobal && commonjsGlobal.__importStar || function(mod) {
+  if (mod && mod.__esModule)
+    return mod;
+  var result = {};
+  if (mod != null) {
+    for (var k in mod)
+      if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+        __createBinding$2(result, mod, k);
+  }
+  __setModuleDefault$2(result, mod);
+  return result;
+};
+Object.defineProperty(base64, "__esModule", { value: true });
+base64.fromBase64 = base64.toBase64 = void 0;
+const base64js = __importStar$2(base64Js);
+function toBase64(data) {
+  return base64js.fromByteArray(data);
+}
+base64.toBase64 = toBase64;
+function fromBase64(base64String) {
+  if (!base64String.match(/^[a-zA-Z0-9+/]*={0,2}$/)) {
+    throw new Error("Invalid base64 string format");
+  }
+  return base64js.toByteArray(base64String);
+}
+base64.fromBase64 = fromBase64;
+var bech32$1 = {};
+var __createBinding$1 = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+  if (k2 === void 0)
+    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 === void 0)
+    k2 = k;
+  o[k2] = m[k];
+});
+var __setModuleDefault$1 = commonjsGlobal && commonjsGlobal.__setModuleDefault || (Object.create ? function(o, v) {
+  Object.defineProperty(o, "default", { enumerable: true, value: v });
+} : function(o, v) {
+  o["default"] = v;
+});
+var __importStar$1 = commonjsGlobal && commonjsGlobal.__importStar || function(mod) {
+  if (mod && mod.__esModule)
+    return mod;
+  var result = {};
+  if (mod != null) {
+    for (var k in mod)
+      if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+        __createBinding$1(result, mod, k);
+  }
+  __setModuleDefault$1(result, mod);
+  return result;
+};
+Object.defineProperty(bech32$1, "__esModule", { value: true });
+bech32$1.normalizeBech32 = bech32$1.fromBech32 = bech32$1.toBech32 = void 0;
+const bech32 = __importStar$1(bech32$2);
+function toBech32(prefix, data, limit) {
+  const address = bech32.encode(prefix, bech32.toWords(data), limit);
+  return address;
+}
+bech32$1.toBech32 = toBech32;
+function fromBech32(address, limit = Infinity) {
+  const decodedAddress = bech32.decode(address, limit);
+  return {
+    prefix: decodedAddress.prefix,
+    data: new Uint8Array(bech32.fromWords(decodedAddress.words))
+  };
+}
+bech32$1.fromBech32 = fromBech32;
+function normalizeBech32(address) {
+  const { prefix, data } = fromBech32(address);
+  return toBech32(prefix, data);
+}
+bech32$1.normalizeBech32 = normalizeBech32;
+var hex = {};
+Object.defineProperty(hex, "__esModule", { value: true });
+hex.fromHex = hex.toHex = void 0;
+function toHex(data) {
+  let out = "";
+  for (const byte of data) {
+    out += ("0" + byte.toString(16)).slice(-2);
+  }
+  return out;
+}
+hex.toHex = toHex;
+function fromHex(hexstring) {
+  if (hexstring.length % 2 !== 0) {
+    throw new Error("hex string length must be a multiple of 2");
+  }
+  const out = new Uint8Array(hexstring.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    const j = 2 * i;
+    const hexByteAsString = hexstring.slice(j, j + 2);
+    if (!hexByteAsString.match(/[0-9a-f]{2}/i)) {
+      throw new Error("hex string contains invalid characters");
+    }
+    out[i] = parseInt(hexByteAsString, 16);
+  }
+  return out;
+}
+hex.fromHex = fromHex;
+var rfc3339 = {};
+Object.defineProperty(rfc3339, "__esModule", { value: true });
+rfc3339.toRfc3339 = rfc3339.fromRfc3339 = void 0;
+const rfc3339Matcher = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(\.\d{1,9})?((?:[+-]\d{2}:\d{2})|Z)$/;
+function padded(integer, length = 2) {
+  return integer.toString().padStart(length, "0");
+}
+function fromRfc3339(str) {
+  const matches = rfc3339Matcher.exec(str);
+  if (!matches) {
+    throw new Error("Date string is not in RFC3339 format");
+  }
+  const year = +matches[1];
+  const month = +matches[2];
+  const day = +matches[3];
+  const hour = +matches[4];
+  const minute = +matches[5];
+  const second = +matches[6];
+  const milliSeconds = matches[7] ? Math.floor(+matches[7] * 1e3) : 0;
+  let tzOffsetSign;
+  let tzOffsetHours;
+  let tzOffsetMinutes;
+  if (matches[8] === "Z") {
+    tzOffsetSign = 1;
+    tzOffsetHours = 0;
+    tzOffsetMinutes = 0;
+  } else {
+    tzOffsetSign = matches[8].substring(0, 1) === "-" ? -1 : 1;
+    tzOffsetHours = +matches[8].substring(1, 3);
+    tzOffsetMinutes = +matches[8].substring(4, 6);
+  }
+  const tzOffset = tzOffsetSign * (tzOffsetHours * 60 + tzOffsetMinutes) * 60;
+  const timestamp = Date.UTC(year, month - 1, day, hour, minute, second, milliSeconds) - tzOffset * 1e3;
+  return new Date(timestamp);
+}
+rfc3339.fromRfc3339 = fromRfc3339;
+function toRfc3339(date) {
+  const year = date.getUTCFullYear();
+  const month = padded(date.getUTCMonth() + 1);
+  const day = padded(date.getUTCDate());
+  const hour = padded(date.getUTCHours());
+  const minute = padded(date.getUTCMinutes());
+  const second = padded(date.getUTCSeconds());
+  const ms = padded(date.getUTCMilliseconds(), 3);
+  return `${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}Z`;
+}
+rfc3339.toRfc3339 = toRfc3339;
+var utf8 = {};
+Object.defineProperty(utf8, "__esModule", { value: true });
+utf8.fromUtf8 = utf8.toUtf8 = void 0;
+function toUtf8(str) {
+  return new TextEncoder().encode(str);
+}
+utf8.toUtf8 = toUtf8;
+function fromUtf8(data, lossy = false) {
+  const fatal = !lossy;
+  return new TextDecoder("utf-8", { fatal }).decode(data);
+}
+utf8.fromUtf8 = fromUtf8;
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.toUtf8 = exports.fromUtf8 = exports.toRfc3339 = exports.fromRfc3339 = exports.toHex = exports.fromHex = exports.toBech32 = exports.normalizeBech32 = exports.fromBech32 = exports.toBase64 = exports.fromBase64 = exports.toAscii = exports.fromAscii = void 0;
+  var ascii_1 = ascii;
+  Object.defineProperty(exports, "fromAscii", { enumerable: true, get: function() {
+    return ascii_1.fromAscii;
+  } });
+  Object.defineProperty(exports, "toAscii", { enumerable: true, get: function() {
+    return ascii_1.toAscii;
+  } });
+  var base64_1 = base64;
+  Object.defineProperty(exports, "fromBase64", { enumerable: true, get: function() {
+    return base64_1.fromBase64;
+  } });
+  Object.defineProperty(exports, "toBase64", { enumerable: true, get: function() {
+    return base64_1.toBase64;
+  } });
+  var bech32_1 = bech32$1;
+  Object.defineProperty(exports, "fromBech32", { enumerable: true, get: function() {
+    return bech32_1.fromBech32;
+  } });
+  Object.defineProperty(exports, "normalizeBech32", { enumerable: true, get: function() {
+    return bech32_1.normalizeBech32;
+  } });
+  Object.defineProperty(exports, "toBech32", { enumerable: true, get: function() {
+    return bech32_1.toBech32;
+  } });
+  var hex_1 = hex;
+  Object.defineProperty(exports, "fromHex", { enumerable: true, get: function() {
+    return hex_1.fromHex;
+  } });
+  Object.defineProperty(exports, "toHex", { enumerable: true, get: function() {
+    return hex_1.toHex;
+  } });
+  var rfc3339_1 = rfc3339;
+  Object.defineProperty(exports, "fromRfc3339", { enumerable: true, get: function() {
+    return rfc3339_1.fromRfc3339;
+  } });
+  Object.defineProperty(exports, "toRfc3339", { enumerable: true, get: function() {
+    return rfc3339_1.toRfc3339;
+  } });
+  var utf8_1 = utf8;
+  Object.defineProperty(exports, "fromUtf8", { enumerable: true, get: function() {
+    return utf8_1.fromUtf8;
+  } });
+  Object.defineProperty(exports, "toUtf8", { enumerable: true, get: function() {
+    return utf8_1.toUtf8;
+  } });
+})(build$1);
+var pbkdf2$2 = {};
 var build = {};
 var arrays = {};
 Object.defineProperty(arrays, "__esModule", { value: true });
@@ -136,6 +814,510 @@ typechecks.isDefined = isDefined;
     return typechecks_1.isUint8Array;
   } });
 })(build);
+var pbkdf2$1 = {};
+var hmac$1 = {};
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.hmac = exports.HMAC = void 0;
+  const _assert_js_12 = _assert;
+  const utils_js_12 = utils$1;
+  class HMAC extends utils_js_12.Hash {
+    constructor(hash, _key) {
+      super();
+      this.finished = false;
+      this.destroyed = false;
+      (0, _assert_js_12.hash)(hash);
+      const key = (0, utils_js_12.toBytes)(_key);
+      this.iHash = hash.create();
+      if (typeof this.iHash.update !== "function")
+        throw new Error("Expected instance of class which extends utils.Hash");
+      this.blockLen = this.iHash.blockLen;
+      this.outputLen = this.iHash.outputLen;
+      const blockLen = this.blockLen;
+      const pad = new Uint8Array(blockLen);
+      pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+      for (let i = 0; i < pad.length; i++)
+        pad[i] ^= 54;
+      this.iHash.update(pad);
+      this.oHash = hash.create();
+      for (let i = 0; i < pad.length; i++)
+        pad[i] ^= 54 ^ 92;
+      this.oHash.update(pad);
+      pad.fill(0);
+    }
+    update(buf) {
+      (0, _assert_js_12.exists)(this);
+      this.iHash.update(buf);
+      return this;
+    }
+    digestInto(out) {
+      (0, _assert_js_12.exists)(this);
+      (0, _assert_js_12.bytes)(out, this.outputLen);
+      this.finished = true;
+      this.iHash.digestInto(out);
+      this.oHash.update(out);
+      this.oHash.digestInto(out);
+      this.destroy();
+    }
+    digest() {
+      const out = new Uint8Array(this.oHash.outputLen);
+      this.digestInto(out);
+      return out;
+    }
+    _cloneInto(to) {
+      to || (to = Object.create(Object.getPrototypeOf(this), {}));
+      const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+      to = to;
+      to.finished = finished;
+      to.destroyed = destroyed;
+      to.blockLen = blockLen;
+      to.outputLen = outputLen;
+      to.oHash = oHash._cloneInto(to.oHash);
+      to.iHash = iHash._cloneInto(to.iHash);
+      return to;
+    }
+    destroy() {
+      this.destroyed = true;
+      this.oHash.destroy();
+      this.iHash.destroy();
+    }
+  }
+  exports.HMAC = HMAC;
+  const hmac2 = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+  exports.hmac = hmac2;
+  exports.hmac.create = (hash, key) => new HMAC(hash, key);
+})(hmac$1);
+Object.defineProperty(pbkdf2$1, "__esModule", { value: true });
+pbkdf2$1.pbkdf2Async = pbkdf2$1.pbkdf2 = void 0;
+const _assert_js_1$1 = _assert;
+const hmac_js_1 = hmac$1;
+const utils_js_1$3 = utils$1;
+function pbkdf2Init(hash, _password, _salt, _opts) {
+  (0, _assert_js_1$1.hash)(hash);
+  const opts = (0, utils_js_1$3.checkOpts)({ dkLen: 32, asyncTick: 10 }, _opts);
+  const { c, dkLen, asyncTick } = opts;
+  (0, _assert_js_1$1.number)(c);
+  (0, _assert_js_1$1.number)(dkLen);
+  (0, _assert_js_1$1.number)(asyncTick);
+  if (c < 1)
+    throw new Error("PBKDF2: iterations (c) should be >= 1");
+  const password = (0, utils_js_1$3.toBytes)(_password);
+  const salt = (0, utils_js_1$3.toBytes)(_salt);
+  const DK = new Uint8Array(dkLen);
+  const PRF = hmac_js_1.hmac.create(hash, password);
+  const PRFSalt = PRF._cloneInto().update(salt);
+  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+  PRF.destroy();
+  PRFSalt.destroy();
+  if (prfW)
+    prfW.destroy();
+  u.fill(0);
+  return DK;
+}
+function pbkdf2(hash, password, salt, opts) {
+  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+  let prfW;
+  const arr = new Uint8Array(4);
+  const view = (0, utils_js_1$3.createView)(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    for (let ui = 1; ui < c; ui++) {
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i = 0; i < Ti.length; i++)
+        Ti[i] ^= u[i];
+    }
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+pbkdf2$1.pbkdf2 = pbkdf2;
+async function pbkdf2Async(hash, password, salt, opts) {
+  const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+  let prfW;
+  const arr = new Uint8Array(4);
+  const view = (0, utils_js_1$3.createView)(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    await (0, utils_js_1$3.asyncLoop)(c - 1, asyncTick, () => {
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i = 0; i < Ti.length; i++)
+        Ti[i] ^= u[i];
+    });
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+pbkdf2$1.pbkdf2Async = pbkdf2Async;
+var sha512$1 = {};
+var _u64 = {};
+Object.defineProperty(_u64, "__esModule", { value: true });
+_u64.add5L = _u64.add5H = _u64.add4H = _u64.add4L = _u64.add3H = _u64.add3L = _u64.add = _u64.rotlBL = _u64.rotlBH = _u64.rotlSL = _u64.rotlSH = _u64.rotr32L = _u64.rotr32H = _u64.rotrBL = _u64.rotrBH = _u64.rotrSL = _u64.rotrSH = _u64.shrSL = _u64.shrSH = _u64.toBig = _u64.split = _u64.fromBig = void 0;
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+_u64.fromBig = fromBig;
+function split(lst, le = false) {
+  let Ah = new Uint32Array(lst.length);
+  let Al = new Uint32Array(lst.length);
+  for (let i = 0; i < lst.length; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+_u64.split = split;
+const toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
+_u64.toBig = toBig;
+const shrSH = (h, _l, s) => h >>> s;
+_u64.shrSH = shrSH;
+const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+_u64.shrSL = shrSL;
+const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+_u64.rotrSH = rotrSH;
+const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+_u64.rotrSL = rotrSL;
+const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+_u64.rotrBH = rotrBH;
+const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+_u64.rotrBL = rotrBL;
+const rotr32H = (_h, l) => l;
+_u64.rotr32H = rotr32H;
+const rotr32L = (h, _l) => h;
+_u64.rotr32L = rotr32L;
+const rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+_u64.rotlSH = rotlSH;
+const rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+_u64.rotlSL = rotlSL;
+const rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+_u64.rotlBH = rotlBH;
+const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+_u64.rotlBL = rotlBL;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+_u64.add = add;
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+_u64.add3L = add3L;
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+_u64.add3H = add3H;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+_u64.add4L = add4L;
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+_u64.add4H = add4H;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+_u64.add5L = add5L;
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+_u64.add5H = add5H;
+const u64 = {
+  fromBig,
+  split,
+  toBig,
+  shrSH,
+  shrSL,
+  rotrSH,
+  rotrSL,
+  rotrBH,
+  rotrBL,
+  rotr32H,
+  rotr32L,
+  rotlSH,
+  rotlSL,
+  rotlBH,
+  rotlBL,
+  add,
+  add3L,
+  add3H,
+  add4L,
+  add4H,
+  add5H,
+  add5L
+};
+_u64.default = u64;
+Object.defineProperty(sha512$1, "__esModule", { value: true });
+sha512$1.sha384 = sha512$1.sha512_256 = sha512$1.sha512_224 = sha512$1.sha512 = sha512$1.SHA512 = void 0;
+const _sha2_js_1$1 = _sha2;
+const _u64_js_1$1 = _u64;
+const utils_js_1$2 = utils$1;
+const [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => _u64_js_1$1.default.split([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((n) => BigInt(n))))();
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+class SHA512 extends _sha2_js_1$1.SHA2 {
+  constructor() {
+    super(128, 64, 16, false);
+    this.Ah = 1779033703 | 0;
+    this.Al = 4089235720 | 0;
+    this.Bh = 3144134277 | 0;
+    this.Bl = 2227873595 | 0;
+    this.Ch = 1013904242 | 0;
+    this.Cl = 4271175723 | 0;
+    this.Dh = 2773480762 | 0;
+    this.Dl = 1595750129 | 0;
+    this.Eh = 1359893119 | 0;
+    this.El = 2917565137 | 0;
+    this.Fh = 2600822924 | 0;
+    this.Fl = 725511199 | 0;
+    this.Gh = 528734635 | 0;
+    this.Gl = 4215389547 | 0;
+    this.Hh = 1541459225 | 0;
+    this.Hl = 327033209 | 0;
+  }
+  // prettier-ignore
+  get() {
+    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+  }
+  // prettier-ignore
+  set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+    this.Ah = Ah | 0;
+    this.Al = Al | 0;
+    this.Bh = Bh | 0;
+    this.Bl = Bl | 0;
+    this.Ch = Ch | 0;
+    this.Cl = Cl | 0;
+    this.Dh = Dh | 0;
+    this.Dl = Dl | 0;
+    this.Eh = Eh | 0;
+    this.El = El | 0;
+    this.Fh = Fh | 0;
+    this.Fl = Fl | 0;
+    this.Gh = Gh | 0;
+    this.Gl = Gl | 0;
+    this.Hh = Hh | 0;
+    this.Hl = Hl | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4) {
+      SHA512_W_H[i] = view.getUint32(offset);
+      SHA512_W_L[i] = view.getUint32(offset += 4);
+    }
+    for (let i = 16; i < 80; i++) {
+      const W15h = SHA512_W_H[i - 15] | 0;
+      const W15l = SHA512_W_L[i - 15] | 0;
+      const s0h = _u64_js_1$1.default.rotrSH(W15h, W15l, 1) ^ _u64_js_1$1.default.rotrSH(W15h, W15l, 8) ^ _u64_js_1$1.default.shrSH(W15h, W15l, 7);
+      const s0l = _u64_js_1$1.default.rotrSL(W15h, W15l, 1) ^ _u64_js_1$1.default.rotrSL(W15h, W15l, 8) ^ _u64_js_1$1.default.shrSL(W15h, W15l, 7);
+      const W2h = SHA512_W_H[i - 2] | 0;
+      const W2l = SHA512_W_L[i - 2] | 0;
+      const s1h = _u64_js_1$1.default.rotrSH(W2h, W2l, 19) ^ _u64_js_1$1.default.rotrBH(W2h, W2l, 61) ^ _u64_js_1$1.default.shrSH(W2h, W2l, 6);
+      const s1l = _u64_js_1$1.default.rotrSL(W2h, W2l, 19) ^ _u64_js_1$1.default.rotrBL(W2h, W2l, 61) ^ _u64_js_1$1.default.shrSL(W2h, W2l, 6);
+      const SUMl = _u64_js_1$1.default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+      const SUMh = _u64_js_1$1.default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+      SHA512_W_H[i] = SUMh | 0;
+      SHA512_W_L[i] = SUMl | 0;
+    }
+    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    for (let i = 0; i < 80; i++) {
+      const sigma1h = _u64_js_1$1.default.rotrSH(Eh, El, 14) ^ _u64_js_1$1.default.rotrSH(Eh, El, 18) ^ _u64_js_1$1.default.rotrBH(Eh, El, 41);
+      const sigma1l = _u64_js_1$1.default.rotrSL(Eh, El, 14) ^ _u64_js_1$1.default.rotrSL(Eh, El, 18) ^ _u64_js_1$1.default.rotrBL(Eh, El, 41);
+      const CHIh = Eh & Fh ^ ~Eh & Gh;
+      const CHIl = El & Fl ^ ~El & Gl;
+      const T1ll = _u64_js_1$1.default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+      const T1h = _u64_js_1$1.default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+      const T1l = T1ll | 0;
+      const sigma0h = _u64_js_1$1.default.rotrSH(Ah, Al, 28) ^ _u64_js_1$1.default.rotrBH(Ah, Al, 34) ^ _u64_js_1$1.default.rotrBH(Ah, Al, 39);
+      const sigma0l = _u64_js_1$1.default.rotrSL(Ah, Al, 28) ^ _u64_js_1$1.default.rotrBL(Ah, Al, 34) ^ _u64_js_1$1.default.rotrBL(Ah, Al, 39);
+      const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+      const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+      Hh = Gh | 0;
+      Hl = Gl | 0;
+      Gh = Fh | 0;
+      Gl = Fl | 0;
+      Fh = Eh | 0;
+      Fl = El | 0;
+      ({ h: Eh, l: El } = _u64_js_1$1.default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+      Dh = Ch | 0;
+      Dl = Cl | 0;
+      Ch = Bh | 0;
+      Cl = Bl | 0;
+      Bh = Ah | 0;
+      Bl = Al | 0;
+      const All = _u64_js_1$1.default.add3L(T1l, sigma0l, MAJl);
+      Ah = _u64_js_1$1.default.add3H(All, T1h, sigma0h, MAJh);
+      Al = All | 0;
+    }
+    ({ h: Ah, l: Al } = _u64_js_1$1.default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+    ({ h: Bh, l: Bl } = _u64_js_1$1.default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+    ({ h: Ch, l: Cl } = _u64_js_1$1.default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+    ({ h: Dh, l: Dl } = _u64_js_1$1.default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+    ({ h: Eh, l: El } = _u64_js_1$1.default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+    ({ h: Fh, l: Fl } = _u64_js_1$1.default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+    ({ h: Gh, l: Gl } = _u64_js_1$1.default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+    ({ h: Hh, l: Hl } = _u64_js_1$1.default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+  }
+  roundClean() {
+    SHA512_W_H.fill(0);
+    SHA512_W_L.fill(0);
+  }
+  destroy() {
+    this.buffer.fill(0);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+sha512$1.SHA512 = SHA512;
+class SHA512_224 extends SHA512 {
+  constructor() {
+    super();
+    this.Ah = 2352822216 | 0;
+    this.Al = 424955298 | 0;
+    this.Bh = 1944164710 | 0;
+    this.Bl = 2312950998 | 0;
+    this.Ch = 502970286 | 0;
+    this.Cl = 855612546 | 0;
+    this.Dh = 1738396948 | 0;
+    this.Dl = 1479516111 | 0;
+    this.Eh = 258812777 | 0;
+    this.El = 2077511080 | 0;
+    this.Fh = 2011393907 | 0;
+    this.Fl = 79989058 | 0;
+    this.Gh = 1067287976 | 0;
+    this.Gl = 1780299464 | 0;
+    this.Hh = 286451373 | 0;
+    this.Hl = 2446758561 | 0;
+    this.outputLen = 28;
+  }
+}
+class SHA512_256 extends SHA512 {
+  constructor() {
+    super();
+    this.Ah = 573645204 | 0;
+    this.Al = 4230739756 | 0;
+    this.Bh = 2673172387 | 0;
+    this.Bl = 3360449730 | 0;
+    this.Ch = 596883563 | 0;
+    this.Cl = 1867755857 | 0;
+    this.Dh = 2520282905 | 0;
+    this.Dl = 1497426621 | 0;
+    this.Eh = 2519219938 | 0;
+    this.El = 2827943907 | 0;
+    this.Fh = 3193839141 | 0;
+    this.Fl = 1401305490 | 0;
+    this.Gh = 721525244 | 0;
+    this.Gl = 746961066 | 0;
+    this.Hh = 246885852 | 0;
+    this.Hl = 2177182882 | 0;
+    this.outputLen = 32;
+  }
+}
+class SHA384 extends SHA512 {
+  constructor() {
+    super();
+    this.Ah = 3418070365 | 0;
+    this.Al = 3238371032 | 0;
+    this.Bh = 1654270250 | 0;
+    this.Bl = 914150663 | 0;
+    this.Ch = 2438529370 | 0;
+    this.Cl = 812702999 | 0;
+    this.Dh = 355462360 | 0;
+    this.Dl = 4144912697 | 0;
+    this.Eh = 1731405415 | 0;
+    this.El = 4290775857 | 0;
+    this.Fh = 2394180231 | 0;
+    this.Fl = 1750603025 | 0;
+    this.Gh = 3675008525 | 0;
+    this.Gl = 1694076839 | 0;
+    this.Hh = 1203062813 | 0;
+    this.Hl = 3204075428 | 0;
+    this.outputLen = 48;
+  }
+}
+sha512$1.sha512 = (0, utils_js_1$2.wrapConstructor)(() => new SHA512());
+sha512$1.sha512_224 = (0, utils_js_1$2.wrapConstructor)(() => new SHA512_224());
+sha512$1.sha512_256 = (0, utils_js_1$2.wrapConstructor)(() => new SHA512_256());
+sha512$1.sha384 = (0, utils_js_1$2.wrapConstructor)(() => new SHA384());
 var __createBinding = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
   if (k2 === void 0)
     k2 = k;
@@ -168,8 +1350,8 @@ var __importStar = commonjsGlobal && commonjsGlobal.__importStar || function(mod
   __setModuleDefault(result, mod);
   return result;
 };
-Object.defineProperty(pbkdf2, "__esModule", { value: true });
-pbkdf2.pbkdf2Sha512 = pbkdf2.pbkdf2Sha512Noble = pbkdf2.pbkdf2Sha512NodeCrypto = pbkdf2.pbkdf2Sha512Subtle = pbkdf2.getSubtle = pbkdf2.getNodeCrypto = void 0;
+Object.defineProperty(pbkdf2$2, "__esModule", { value: true });
+pbkdf2$2.pbkdf2Sha512 = pbkdf2$2.pbkdf2Sha512Noble = pbkdf2$2.pbkdf2Sha512NodeCrypto = pbkdf2$2.pbkdf2Sha512Subtle = pbkdf2$2.getSubtle = pbkdf2$2.getNodeCrypto = void 0;
 const utils_1$6 = build;
 const pbkdf2_1$1 = pbkdf2$1;
 const sha512_1$1 = sha512$1;
@@ -184,7 +1366,7 @@ async function getNodeCrypto() {
     return void 0;
   }
 }
-pbkdf2.getNodeCrypto = getNodeCrypto;
+pbkdf2$2.getNodeCrypto = getNodeCrypto;
 async function getSubtle() {
   var _a, _b, _c;
   let subtle = (_a = globalThis == null ? void 0 : globalThis.crypto) == null ? void 0 : _a.subtle;
@@ -192,7 +1374,7 @@ async function getSubtle() {
     subtle = (_c = (_b = globalThis == null ? void 0 : globalThis.crypto) == null ? void 0 : _b.webcrypto) == null ? void 0 : _c.subtle;
   return subtle;
 }
-pbkdf2.getSubtle = getSubtle;
+pbkdf2$2.getSubtle = getSubtle;
 async function pbkdf2Sha512Subtle(subtle, secret, salt, iterations, keylen) {
   (0, utils_1$6.assert)(subtle, "Argument subtle is falsy");
   (0, utils_1$6.assert)(typeof subtle === "object", "Argument subtle is not of type object");
@@ -205,7 +1387,7 @@ async function pbkdf2Sha512Subtle(subtle, secret, salt, iterations, keylen) {
     hash: { name: "SHA-512" }
   }, key, keylen * 8).then((buffer2) => new Uint8Array(buffer2)));
 }
-pbkdf2.pbkdf2Sha512Subtle = pbkdf2Sha512Subtle;
+pbkdf2$2.pbkdf2Sha512Subtle = pbkdf2Sha512Subtle;
 async function pbkdf2Sha512NodeCrypto(nodeCrypto, secret, salt, iterations, keylen) {
   (0, utils_1$6.assert)(nodeCrypto, "Argument nodeCrypto is falsy");
   (0, utils_1$6.assert)(typeof nodeCrypto === "object", "Argument nodeCrypto is not of type object");
@@ -220,11 +1402,11 @@ async function pbkdf2Sha512NodeCrypto(nodeCrypto, secret, salt, iterations, keyl
     });
   });
 }
-pbkdf2.pbkdf2Sha512NodeCrypto = pbkdf2Sha512NodeCrypto;
+pbkdf2$2.pbkdf2Sha512NodeCrypto = pbkdf2Sha512NodeCrypto;
 async function pbkdf2Sha512Noble(secret, salt, iterations, keylen) {
   return (0, pbkdf2_1$1.pbkdf2Async)(sha512_1$1.sha512, secret, salt, { c: iterations, dkLen: keylen });
 }
-pbkdf2.pbkdf2Sha512Noble = pbkdf2Sha512Noble;
+pbkdf2$2.pbkdf2Sha512Noble = pbkdf2Sha512Noble;
 async function pbkdf2Sha512(secret, salt, iterations, keylen) {
   const subtle = await getSubtle();
   if (subtle) {
@@ -238,7 +1420,7 @@ async function pbkdf2Sha512(secret, salt, iterations, keylen) {
     }
   }
 }
-pbkdf2.pbkdf2Sha512 = pbkdf2Sha512;
+pbkdf2$2.pbkdf2Sha512 = pbkdf2Sha512;
 var sha = {};
 var utils = {};
 Object.defineProperty(utils, "__esModule", { value: true });
@@ -299,8 +1481,8 @@ function sha512(data) {
 sha.sha512 = sha512;
 Object.defineProperty(bip39, "__esModule", { value: true });
 bip39.Bip39 = bip39.EnglishMnemonic = bip39.mnemonicToEntropy = bip39.entropyToMnemonic = void 0;
-const encoding_1$8 = build$3;
-const pbkdf2_1 = pbkdf2;
+const encoding_1$8 = build$1;
+const pbkdf2_1 = pbkdf2$2;
 const sha_1 = sha;
 const wordlist = [
   "abandon",
@@ -2715,7 +3897,7 @@ function keccak256(data) {
 keccak.keccak256 = keccak256;
 var libsodium = {};
 var libsodiumWrappers = {};
-const __dirname = "/Users/highlander/WebstormProjects/pioneer-react-v2/node_modules/.pnpm/registry.npmjs.org+libsodium-sumo@0.7.13/node_modules/libsodium-sumo/dist/modules-sumo";
+const __dirname = "/Users/highlander/WebstormProjects/pioneer-react-v2/node_modules/.pnpm/libsodium-sumo@0.7.13/node_modules/libsodium-sumo/dist/modules-sumo";
 var libsodiumSumo = { exports: {} };
 function normalizeArray(parts, allowAboveRoot) {
   var up = 0;
@@ -10497,7 +11679,7 @@ var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || functi
 };
 Object.defineProperty(secp256k1$1, "__esModule", { value: true });
 secp256k1$1.Secp256k1 = void 0;
-const encoding_1$7 = build$3;
+const encoding_1$7 = build$1;
 const bn_js_1 = __importDefault(bnExports);
 const elliptic_1 = __importDefault(elliptic);
 const secp256k1signature_1 = secp256k1signature;
@@ -10620,7 +11802,7 @@ var slip10 = {};
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.stringToPath = exports.pathToString = exports.Slip10 = exports.Slip10RawIndex = exports.slip10CurveFromString = exports.Slip10Curve = void 0;
-  const encoding_12 = build$3;
+  const encoding_12 = build$1;
   const math_12 = build$4;
   const bn_js_12 = __importDefault2(bnExports);
   const elliptic_12 = __importDefault2(elliptic);
@@ -10869,7 +12051,7 @@ var slip10 = {};
   Object.defineProperty(exports, "stringToPath", { enumerable: true, get: function() {
     return slip10_1.stringToPath;
   } });
-})(build$1);
+})(build$2);
 var encoding = {};
 var pubkeys = {};
 (function(exports) {
@@ -10904,7 +12086,7 @@ var pubkeys = {};
 })(pubkeys);
 Object.defineProperty(encoding, "__esModule", { value: true });
 encoding.encodeBech32Pubkey = encoding.encodeAminoPubkey = encoding.decodeBech32Pubkey = encoding.decodeAminoPubkey = encoding.encodeEd25519Pubkey = encoding.encodeSecp256k1Pubkey = void 0;
-const encoding_1$6 = build$3;
+const encoding_1$6 = build$1;
 const math_1$3 = build$4;
 const utils_1$1 = build;
 const pubkeys_1$2 = pubkeys;
@@ -11059,8 +12241,8 @@ function encodeBech32Pubkey(pubkey, prefix) {
 encoding.encodeBech32Pubkey = encodeBech32Pubkey;
 Object.defineProperty(addresses, "__esModule", { value: true });
 addresses.pubkeyToAddress = addresses.pubkeyToRawAddress = addresses.rawSecp256k1PubkeyToRawAddress = addresses.rawEd25519PubkeyToRawAddress = void 0;
-const crypto_1$3 = build$1;
-const encoding_1$5 = build$3;
+const crypto_1$3 = build$2;
+const encoding_1$5 = build$1;
 const encoding_2$1 = encoding;
 const pubkeys_1$1 = pubkeys;
 function rawEd25519PubkeyToRawAddress(pubkeyData) {
@@ -11148,7 +12330,7 @@ coins$1.addCoins = addCoins;
 var multisig = {};
 Object.defineProperty(multisig, "__esModule", { value: true });
 multisig.createMultisigThresholdPubkey = multisig.compareArrays = void 0;
-const encoding_1$4 = build$3;
+const encoding_1$4 = build$1;
 const math_1$1 = build$4;
 const addresses_1$2 = addresses;
 function compareArrays(a, b) {
@@ -11179,7 +12361,7 @@ multisig.createMultisigThresholdPubkey = createMultisigThresholdPubkey;
 var paths = {};
 Object.defineProperty(paths, "__esModule", { value: true });
 paths.makeCosmoshubPath = void 0;
-const crypto_1$2 = build$1;
+const crypto_1$2 = build$2;
 function makeCosmoshubPath(a) {
   return [
     crypto_1$2.Slip10RawIndex.hardened(44),
@@ -11194,7 +12376,7 @@ var secp256k1hdwallet = {};
 var signature = {};
 Object.defineProperty(signature, "__esModule", { value: true });
 signature.decodeSignature = signature.encodeSecp256k1Signature = void 0;
-const encoding_1$3 = build$3;
+const encoding_1$3 = build$1;
 const encoding_2 = encoding;
 const pubkeys_1 = pubkeys;
 function encodeSecp256k1Signature(pubkey, signature2) {
@@ -11222,7 +12404,7 @@ signature.decodeSignature = decodeSignature;
 var signdoc = {};
 Object.defineProperty(signdoc, "__esModule", { value: true });
 signdoc.serializeSignDoc = signdoc.escapeCharacters = signdoc.makeSignDoc = signdoc.sortedJsonStringify = void 0;
-const encoding_1$2 = build$3;
+const encoding_1$2 = build$1;
 const math_1 = build$4;
 function sortedObject(obj) {
   if (typeof obj !== "object" || obj === null) {
@@ -11269,8 +12451,8 @@ var wallet = {};
 (function(exports) {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.decrypt = exports.encrypt = exports.supportedAlgorithms = exports.executeKdf = exports.cosmjsSalt = void 0;
-  const crypto_12 = build$1;
-  const encoding_12 = build$3;
+  const crypto_12 = build$2;
+  const encoding_12 = build$1;
   exports.cosmjsSalt = (0, encoding_12.toAscii)("The CosmJS salt.");
   async function executeKdf(password, configuration) {
     switch (configuration.algorithm) {
@@ -11316,8 +12498,8 @@ var wallet = {};
 })(wallet);
 Object.defineProperty(secp256k1hdwallet, "__esModule", { value: true });
 secp256k1hdwallet.Secp256k1HdWallet = secp256k1hdwallet.extractKdfConfiguration = void 0;
-const crypto_1$1 = build$1;
-const encoding_1$1 = build$3;
+const crypto_1$1 = build$2;
+const encoding_1$1 = build$1;
 const utils_1 = build;
 const addresses_1$1 = addresses;
 const paths_1 = paths;
@@ -11554,8 +12736,8 @@ secp256k1hdwallet.Secp256k1HdWallet = Secp256k1HdWallet;
 var secp256k1wallet = {};
 Object.defineProperty(secp256k1wallet, "__esModule", { value: true });
 secp256k1wallet.Secp256k1Wallet = void 0;
-const crypto_1 = build$1;
-const encoding_1 = build$3;
+const crypto_1 = build$2;
+const encoding_1 = build$1;
 const addresses_1 = addresses;
 const signature_1 = signature;
 const signdoc_1 = signdoc;
@@ -11726,16 +12908,17 @@ stdtx.makeStdTx = makeStdTx;
   Object.defineProperty(exports, "executeKdf", { enumerable: true, get: function() {
     return wallet_12.executeKdf;
   } });
-})(build$2);
+})(build$3);
 const index = /* @__PURE__ */ _mergeNamespaces({
   __proto__: null
-}, [build$2]);
+}, [build$3]);
 export {
-  build$2 as a,
+  build$1 as a,
   build as b,
-  build$1 as c,
+  build$2 as c,
+  build$3 as d,
+  build$4 as e,
   index as i,
-  libsodiumWrappers as l,
   ripemd160$1 as r,
-  sha3 as s
+  sha512$1 as s
 };