@pioneer-platform/pioneer-react 0.2.42 → 0.2.45

package/dist/index_b4b501fc.js

@@ -0,0 +1,449 @@
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from "./index_d77fc157.js";
+import { b as bnExports } from "./index_7640e861.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var build = {};
+var decimal = {};
+var __importDefault$1 = 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$1 = __importDefault$1(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$1.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$1.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$1.default(10).pow(new bn_js_1$1.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$1.default(10).pow(new bn_js_1$1.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$1.default(10).pow(new bn_js_1$1.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$1.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$1.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$1.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 = 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 = __importDefault(bnExports);
+const uint64MaxValue = new bn_js_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.default(beBytes));
+  }
+  static fromString(str) {
+    if (!str.match(/^[0-9]+$/)) {
+      throw new Error("Invalid string format");
+    }
+    return new Uint64(new bn_js_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.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);
+const Yi = /* @__PURE__ */ getDefaultExportFromCjs(build);
+const index = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: Yi
+}, [build]);
+export {
+  Yi as Y,
+  build as b,
+  index as i
+};

package/dist/index_b62d8ff4.js

@@ -0,0 +1,30 @@
+import { S, A, m, O, B, T, M, k, d, D, f, F, c, p, N, K, R, a, b, I, e, P } from "./index_3fea9d52.js";
+import "./index_64ff18e7.js";
+import "./index_86436d56.js";
+import "./index_d77fc157.js";
+import "react";
+import "@chakra-ui/react";
+export {
+  S as BCHToolbox,
+  A as BTCToolbox,
+  m as BaseUTXOToolbox,
+  O as DOGEToolbox,
+  B as InputSizes,
+  T as LTCToolbox,
+  M as OP_RETURN_OVERHEAD,
+  k as OutputSizes,
+  d as TX_OVERHEAD,
+  D as UTXOScriptType,
+  f as accumulative,
+  F as calculateTxSize,
+  c as compileMemo,
+  p as getDustThreshold,
+  N as getInputSize,
+  K as getNetwork,
+  R as getOutputSize,
+  a as getScriptTypeForAddress,
+  b as getSeed,
+  I as standardFeeRates,
+  e as uniqid,
+  P as validatePhrase
+};

package/dist/{index_81d780b7.js → index_b6e5a809.js}

@@ -29,7 +29,7 @@ const M = ({ addChain: _, rpcUrls: t }) => async (n) => {
   const i = I == null ? void 0 : I.getOfflineSignerOnlyAmino(R);
   if (!i)
     throw new Error("Could not load offlineSigner");
-  const { getDenom: D, KujiraToolbox: O, GaiaToolbox: e, createCosmJS: c } = await import("./index_9fef85a2.js"), d = await c({ offlineSigner: i, rpcUrl: t[n] }), [{ address: o }] = await i.getAccounts(), C = async ({
+  const { getDenom: D, KujiraToolbox: O, GaiaToolbox: e, createCosmJS: c } = await import("./index_5dc59e18.js"), d = await c({ offlineSigner: i, rpcUrl: t[n] }), [{ address: o }] = await i.getAccounts(), C = async ({
     assetValue: s,
     recipient: P,
     memo: h

package/dist/{index_6424cb67.js → index_bd7bbccf.js}

@@ -1,7 +1,5 @@
-import { c as commonjsGlobal, b as buffer } from "./index_015b6eba.js";
-import { b as build$1, c as build$3, a as build$4 } from "./index_70cc14bd.js";
-import { b as build$2 } from "./index_2143ad7f.js";
-import { b as build$5 } from "./index_e525ec6b.js";
+import { c as commonjsGlobal, f as buffer } from "./index_d77fc157.js";
+import { b as build$1, a as build$2, c as build$3, d as build$4, e as build$5 } from "./index_96d5aad1.js";
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {
     const e = m[i];

package/dist/{index_381aee34.js → index_c2bc068c.js}

@@ -1,4 +1,4 @@
-import { d as dist, g as getDefaultExportFromCjs } from "./index_265bb459.js";
+import { d as dist, g as getDefaultExportFromCjs } from "./index_a9d0b958.js";
 var Re = { exports: {} };
 const $t = "2.0.0", Je = 256, mt = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
 9007199254740991, vt = 16, Rt = Je - 6, gt = [

package/dist/{index_7861fcf0.js → index_c587fd1b.js}

@@ -1,10 +1,9 @@
-import { f, g, I, V, j, U, i, k, q, m, s, p, n, r, G, u, O, v, w, y, H, z, C, D, F, L, N, R, T, W, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, aE, aF, aG, aH, aI, aJ, aK, aL, aM, aN, aO, aP, aQ, aR, aS, aT, aU, aV, aW, aX, aY, aZ, a_, a$, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd } from "./index_a005a882.js";
-import "./index_4b36612f.js";
+import { f, g, I, V, j, U, i, k, q, m, s, p, n, r, G, u, O, v, w, y, H, z, C, D, F, L, N, R, T, W, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, aE, aF, aG, aH, aI, aJ, aK, aL, aM, aN, aO, aP, aQ, aR, aS, aT, aU, aV, aW, aX, aY, aZ, a_, a$, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd } from "./index_87afedd4.js";
+import "./index_64ff18e7.js";
 import "./index_86436d56.js";
-import "./index_015b6eba.js";
+import "./index_d77fc157.js";
 import "react";
 import "@chakra-ui/react";
-import "@emotion/react";
 export {
   f as AbiCoder,
   g as AbstractProvider,

package/dist/{index_239b8e07.js → index_c8c2dada.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs, d as dist } from "./index_265bb459.js";
+import { g as getDefaultExportFromCjs, d as dist } from "./index_a9d0b958.js";
 var l = function(i, e, r, a, o, t, s, d) {
   if (dist.process.env.NODE_ENV !== "production" && e === void 0)
     throw new Error("invariant requires an error message argument");

package/dist/{index_bfa7b443.js → index_d26b5754.js}

@@ -1,14 +1,13 @@
-import { c as commonjsGlobal, m as minimal, l as long, a as any, h as helpers, b as coin, g as getIntrinsic, t as tx, d as dist, e as build, s as signing, f as multisig } from "./index_61bfdb70.js";
-import { a as Ri$1, b as Vn$1, r as VI, s as TI, c as Ar$1, d as Pi$1 } from "./index_6fc14522.js";
-import { t as Te$1, a as xe$1, b as Ne$1 } from "./index_d869d4f8.js";
-import { b as oe$1 } from "./index_ed259edc.js";
-import "./index_aa947e34.js";
-import "./index_4b36612f.js";
+import { c as commonjsGlobal, m as minimal, l as long, a as any, h as helpers, b as coin, g as getIntrinsic, t as tx, d as dist, e as build, s as signing, f as multisig } from "./index_7c574e7d.js";
+import { a as Ri$1, b as Vn$1, r as VI, s as TI, c as Ar$1, d as Pi$1 } from "./index_1a6a5598.js";
+import { t as Te$1, a as xe$1, b as Ne$1 } from "./index_abaa7487.js";
+import { b as oe$1 } from "./index_47217799.js";
+import "./index_9346dd3d.js";
+import "./index_64ff18e7.js";
 import "./index_86436d56.js";
-import "./index_015b6eba.js";
+import "./index_d77fc157.js";
 import "react";
 import "@chakra-ui/react";
-import "@emotion/react";
 function _u(e, n) {
   for (var t = 0; t < n.length; t++) {
     const l = n[t];