@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/tendermint-rpc/node_modules/axios/lib/helpers/validator.mjs

@@ -0,0 +1,56 @@
+import d from "../../package.json.mjs";
+var v = d, u = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(r, n) {
+  u[r] = function(a) {
+    return typeof a === r || "a" + (n < 1 ? "n " : " ") + r;
+  };
+});
+var c = {}, b = v.version.split(".");
+function l(r, n) {
+  for (var t = n ? n.split(".") : b, a = r.split("."), e = 0; e < 3; e++) {
+    if (t[e] > a[e])
+      return !0;
+    if (t[e] < a[e])
+      return !1;
+  }
+  return !1;
+}
+u.transitional = function(n, t, a) {
+  var e = t && l(t);
+  function o(s, i) {
+    return "[Axios v" + v.version + "] Transitional option '" + s + "'" + i + (a ? ". " + a : "");
+  }
+  return function(s, i, f) {
+    if (n === !1)
+      throw new Error(o(i, " has been removed in " + t));
+    return e && !c[i] && (c[i] = !0, console.warn(
+      o(
+        i,
+        " has been deprecated since v" + t + " and will be removed in the near future"
+      )
+    )), n ? n(s, i, f) : !0;
+  };
+};
+function w(r, n, t) {
+  if (typeof r != "object")
+    throw new TypeError("options must be an object");
+  for (var a = Object.keys(r), e = a.length; e-- > 0; ) {
+    var o = a[e], s = n[o];
+    if (s) {
+      var i = r[o], f = i === void 0 || s(i, o, r);
+      if (f !== !0)
+        throw new TypeError("option " + o + " must be " + f);
+      continue;
+    }
+    if (t !== !0)
+      throw Error("Unknown option " + o);
+  }
+}
+var m = {
+  isOlderVersion: l,
+  assertOptions: w,
+  validators: u
+};
+export {
+  m as v
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/tendermint-rpc/node_modules/axios/lib/utils.mjs

@@ -0,0 +1,113 @@
+import { b as m } from "./helpers/bind.mjs";
+var y = m, f = Object.prototype.toString;
+function a(r) {
+  return f.call(r) === "[object Array]";
+}
+function c(r) {
+  return typeof r > "u";
+}
+function B(r) {
+  return r !== null && !c(r) && r.constructor !== null && !c(r.constructor) && typeof r.constructor.isBuffer == "function" && r.constructor.isBuffer(r);
+}
+function g(r) {
+  return f.call(r) === "[object ArrayBuffer]";
+}
+function b(r) {
+  return typeof FormData < "u" && r instanceof FormData;
+}
+function S(r) {
+  var t;
+  return typeof ArrayBuffer < "u" && ArrayBuffer.isView ? t = ArrayBuffer.isView(r) : t = r && r.buffer && r.buffer instanceof ArrayBuffer, t;
+}
+function F(r) {
+  return typeof r == "string";
+}
+function O(r) {
+  return typeof r == "number";
+}
+function p(r) {
+  return r !== null && typeof r == "object";
+}
+function o(r) {
+  if (f.call(r) !== "[object Object]")
+    return !1;
+  var t = Object.getPrototypeOf(r);
+  return t === null || t === Object.prototype;
+}
+function A(r) {
+  return f.call(r) === "[object Date]";
+}
+function h(r) {
+  return f.call(r) === "[object File]";
+}
+function w(r) {
+  return f.call(r) === "[object Blob]";
+}
+function d(r) {
+  return f.call(r) === "[object Function]";
+}
+function P(r) {
+  return p(r) && d(r.pipe);
+}
+function D(r) {
+  return typeof URLSearchParams < "u" && r instanceof URLSearchParams;
+}
+function j(r) {
+  return r.trim ? r.trim() : r.replace(/^\s+|\s+$/g, "");
+}
+function U() {
+  return typeof navigator < "u" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS") ? !1 : typeof window < "u" && typeof document < "u";
+}
+function l(r, t) {
+  if (!(r === null || typeof r > "u"))
+    if (typeof r != "object" && (r = [r]), a(r))
+      for (var n = 0, u = r.length; n < u; n++)
+        t.call(null, r[n], n, r);
+    else
+      for (var e in r)
+        Object.prototype.hasOwnProperty.call(r, e) && t.call(null, r[e], e, r);
+}
+function s() {
+  var r = {};
+  function t(e, i) {
+    o(r[i]) && o(e) ? r[i] = s(r[i], e) : o(e) ? r[i] = s({}, e) : a(e) ? r[i] = e.slice() : r[i] = e;
+  }
+  for (var n = 0, u = arguments.length; n < u; n++)
+    l(arguments[n], t);
+  return r;
+}
+function V(r, t, n) {
+  return l(t, function(e, i) {
+    n && typeof e == "function" ? r[i] = y(e, n) : r[i] = e;
+  }), r;
+}
+function E(r) {
+  return r.charCodeAt(0) === 65279 && (r = r.slice(1)), r;
+}
+var R = {
+  isArray: a,
+  isArrayBuffer: g,
+  isBuffer: B,
+  isFormData: b,
+  isArrayBufferView: S,
+  isString: F,
+  isNumber: O,
+  isObject: p,
+  isPlainObject: o,
+  isUndefined: c,
+  isDate: A,
+  isFile: h,
+  isBlob: w,
+  isFunction: d,
+  isStream: P,
+  isURLSearchParams: D,
+  isStandardBrowserEnv: U,
+  forEach: l,
+  merge: s,
+  extend: V,
+  trim: j,
+  stripBOM: E
+};
+export {
+  R as u
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/tendermint-rpc/node_modules/axios/package.json.mjs

@@ -0,0 +1,105 @@
+const s = "axios", e = "0.21.4", t = "Promise based HTTP client for the browser and node.js", r = "index.js", n = {
+  test: "grunt test",
+  start: "node ./sandbox/server.js",
+  build: "NODE_ENV=production grunt build",
+  preversion: "npm test",
+  version: "npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json",
+  postversion: "git push && git push --tags",
+  examples: "node ./examples/server.js",
+  coveralls: "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
+  fix: "eslint --fix lib/**/*.js"
+}, a = {
+  type: "git",
+  url: "https://github.com/axios/axios.git"
+}, i = [
+  "xhr",
+  "http",
+  "ajax",
+  "promise",
+  "node"
+], o = "Matt Zabriskie", c = "MIT", d = {
+  url: "https://github.com/axios/axios/issues"
+}, p = "https://axios-http.com", u = {
+  coveralls: "^3.0.0",
+  "es6-promise": "^4.2.4",
+  grunt: "^1.3.0",
+  "grunt-banner": "^0.6.0",
+  "grunt-cli": "^1.2.0",
+  "grunt-contrib-clean": "^1.1.0",
+  "grunt-contrib-watch": "^1.0.0",
+  "grunt-eslint": "^23.0.0",
+  "grunt-karma": "^4.0.0",
+  "grunt-mocha-test": "^0.13.3",
+  "grunt-ts": "^6.0.0-beta.19",
+  "grunt-webpack": "^4.0.2",
+  "istanbul-instrumenter-loader": "^1.0.0",
+  "jasmine-core": "^2.4.1",
+  karma: "^6.3.2",
+  "karma-chrome-launcher": "^3.1.0",
+  "karma-firefox-launcher": "^2.1.0",
+  "karma-jasmine": "^1.1.1",
+  "karma-jasmine-ajax": "^0.1.13",
+  "karma-safari-launcher": "^1.0.0",
+  "karma-sauce-launcher": "^4.3.6",
+  "karma-sinon": "^1.0.5",
+  "karma-sourcemap-loader": "^0.3.8",
+  "karma-webpack": "^4.0.2",
+  "load-grunt-tasks": "^3.5.2",
+  minimist: "^1.2.0",
+  mocha: "^8.2.1",
+  sinon: "^4.5.0",
+  "terser-webpack-plugin": "^4.2.3",
+  typescript: "^4.0.5",
+  "url-search-params": "^0.10.0",
+  webpack: "^4.44.2",
+  "webpack-dev-server": "^3.11.0"
+}, l = {
+  "./lib/adapters/http.js": "./lib/adapters/xhr.js"
+}, m = "dist/axios.min.js", g = "dist/axios.min.js", b = "./index.d.ts", h = {
+  "follow-redirects": "^1.14.0"
+}, k = [
+  {
+    path: "./dist/axios.min.js",
+    threshold: "5kB"
+  }
+], x = {
+  name: s,
+  version: e,
+  description: t,
+  main: r,
+  scripts: n,
+  repository: a,
+  keywords: i,
+  author: o,
+  license: c,
+  bugs: d,
+  homepage: p,
+  devDependencies: u,
+  browser: l,
+  jsdelivr: m,
+  unpkg: g,
+  typings: b,
+  dependencies: h,
+  bundlesize: k
+};
+export {
+  o as author,
+  l as browser,
+  d as bugs,
+  k as bundlesize,
+  x as default,
+  h as dependencies,
+  t as description,
+  u as devDependencies,
+  p as homepage,
+  m as jsdelivr,
+  i as keywords,
+  c as license,
+  r as main,
+  s as name,
+  a as repository,
+  n as scripts,
+  b as typings,
+  g as unpkg,
+  e as version
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/utils/build/arrays.mjs

@@ -0,0 +1,24 @@
+import { __exports as n } from "../../../../../../../../../_virtual/arrays.mjs";
+Object.defineProperty(n, "__esModule", { value: !0 });
+n.arrayContentStartsWith = n.arrayContentEquals = void 0;
+function a(r, e) {
+  if (r.length !== e.length)
+    return !1;
+  for (let t = 0; t < r.length; ++t)
+    if (r[t] !== e[t])
+      return !1;
+  return !0;
+}
+n.arrayContentEquals = a;
+function l(r, e) {
+  if (r.length < e.length)
+    return !1;
+  for (let t = 0; t < e.length; ++t)
+    if (r[t] !== e[t])
+      return !1;
+  return !0;
+}
+n.arrayContentStartsWith = l;
+export {
+  n as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/utils/build/assert.mjs

@@ -0,0 +1,21 @@
+import { __exports as e } from "../../../../../../../../../_virtual/assert3.mjs";
+Object.defineProperty(e, "__esModule", { value: !0 });
+e.assertDefinedAndNotNull = e.assertDefined = e.assert = void 0;
+function t(n, r) {
+  if (!n)
+    throw new Error(r || "condition is not truthy");
+}
+e.assert = t;
+function s(n, r) {
+  if (n === void 0)
+    throw new Error(r ?? "value is undefined");
+}
+e.assertDefined = s;
+function i(n, r) {
+  if (n == null)
+    throw new Error(r ?? "value is undefined or null");
+}
+e.assertDefinedAndNotNull = i;
+export {
+  e as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/utils/build/index.mjs

@@ -0,0 +1,38 @@
+import { __exports as i } from "../../../../../../../../../_virtual/index58.mjs";
+import "./arrays.mjs";
+import "./assert.mjs";
+import "./sleep.mjs";
+import "./typechecks.mjs";
+import { __exports as u } from "../../../../../../../../../_virtual/arrays.mjs";
+import { __exports as s } from "../../../../../../../../../_virtual/assert3.mjs";
+import { __exports as o } from "../../../../../../../../../_virtual/sleep2.mjs";
+import { __exports as f } from "../../../../../../../../../_virtual/typechecks.mjs";
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.isUint8Array = e.isNonNullObject = e.isDefined = e.sleep = e.assertDefinedAndNotNull = e.assertDefined = e.assert = e.arrayContentStartsWith = e.arrayContentEquals = void 0;
+  var n = u;
+  Object.defineProperty(e, "arrayContentEquals", { enumerable: !0, get: function() {
+    return n.arrayContentEquals;
+  } }), Object.defineProperty(e, "arrayContentStartsWith", { enumerable: !0, get: function() {
+    return n.arrayContentStartsWith;
+  } });
+  var r = s;
+  Object.defineProperty(e, "assert", { enumerable: !0, get: function() {
+    return r.assert;
+  } }), Object.defineProperty(e, "assertDefined", { enumerable: !0, get: function() {
+    return r.assertDefined;
+  } }), Object.defineProperty(e, "assertDefinedAndNotNull", { enumerable: !0, get: function() {
+    return r.assertDefinedAndNotNull;
+  } });
+  var a = o;
+  Object.defineProperty(e, "sleep", { enumerable: !0, get: function() {
+    return a.sleep;
+  } });
+  var t = f;
+  Object.defineProperty(e, "isDefined", { enumerable: !0, get: function() {
+    return t.isDefined;
+  } }), Object.defineProperty(e, "isNonNullObject", { enumerable: !0, get: function() {
+    return t.isNonNullObject;
+  } }), Object.defineProperty(e, "isUint8Array", { enumerable: !0, get: function() {
+    return t.isUint8Array;
+  } });
+})(i);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/utils/build/sleep.mjs

@@ -0,0 +1,10 @@
+import { __exports as e } from "../../../../../../../../../_virtual/sleep2.mjs";
+Object.defineProperty(e, "__esModule", { value: !0 });
+e.sleep = void 0;
+async function o(s) {
+  return new Promise((t) => setTimeout(t, s));
+}
+e.sleep = o;
+export {
+  e as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/utils/build/typechecks.mjs

@@ -0,0 +1,18 @@
+import { __exports as r } from "../../../../../../../../../_virtual/typechecks.mjs";
+Object.defineProperty(r, "__esModule", { value: !0 });
+r.isDefined = r.isUint8Array = r.isNonNullObject = void 0;
+function f(e) {
+  return typeof e == "object" && e !== null;
+}
+r.isNonNullObject = f;
+function i(e) {
+  return !(!f(e) || Object.prototype.toString.call(e) !== "[object Uint8Array]" || typeof Buffer < "u" && typeof Buffer.isBuffer < "u" && Buffer.isBuffer(e));
+}
+r.isUint8Array = i;
+function t(e) {
+  return e !== void 0;
+}
+r.isDefined = t;
+export {
+  r as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abi/lib.esm/_version.mjs

@@ -0,0 +1,4 @@
+const o = "abi/5.7.0";
+export {
+  o as version
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abi/lib.esm/abi-coder.mjs

@@ -0,0 +1,79 @@
+import { arrayify as u } from "../../bytes/lib.esm/index.mjs";
+import { defineReadOnly as g } from "../../properties/lib.esm/index.mjs";
+import { Logger as m } from "../../logger/lib.esm/index.mjs";
+import { version as l } from "./_version.mjs";
+import { Reader as a, Writer as h } from "./coders/abstract-coder.mjs";
+import { AddressCoder as f } from "./coders/address.mjs";
+import { ArrayCoder as w } from "./coders/array.mjs";
+import { BooleanCoder as p } from "./coders/boolean.mjs";
+import { BytesCoder as y } from "./coders/bytes.mjs";
+import { FixedBytesCoder as C } from "./coders/fixed-bytes.mjs";
+import { NullCoder as _ } from "./coders/null.mjs";
+import { NumberCoder as b } from "./coders/number.mjs";
+import { StringCoder as A } from "./coders/string.mjs";
+import { TupleCoder as n } from "./coders/tuple.mjs";
+import { ParamType as c } from "./fragments.mjs";
+const i = new m(l), E = new RegExp(/^bytes([0-9]*)$/), R = new RegExp(/^(u?int)([0-9]*)$/);
+class T {
+  constructor(e) {
+    g(this, "coerceFunc", e || null);
+  }
+  _getCoder(e) {
+    switch (e.baseType) {
+      case "address":
+        return new f(e.name);
+      case "bool":
+        return new p(e.name);
+      case "string":
+        return new A(e.name);
+      case "bytes":
+        return new y(e.name);
+      case "array":
+        return new w(this._getCoder(e.arrayChildren), e.arrayLength, e.name);
+      case "tuple":
+        return new n((e.components || []).map((t) => this._getCoder(t)), e.name);
+      case "":
+        return new _(e.name);
+    }
+    let r = e.type.match(R);
+    if (r) {
+      let t = parseInt(r[2] || "256");
+      return (t === 0 || t > 256 || t % 8 !== 0) && i.throwArgumentError("invalid " + r[1] + " bit length", "param", e), new b(t / 8, r[1] === "int", e.name);
+    }
+    if (r = e.type.match(E), r) {
+      let t = parseInt(r[1]);
+      return (t === 0 || t > 32) && i.throwArgumentError("invalid bytes length", "param", e), new C(t, e.name);
+    }
+    return i.throwArgumentError("invalid type", "type", e.type);
+  }
+  _getWordSize() {
+    return 32;
+  }
+  _getReader(e, r) {
+    return new a(e, this._getWordSize(), this.coerceFunc, r);
+  }
+  _getWriter() {
+    return new h(this._getWordSize());
+  }
+  getDefaultValue(e) {
+    const r = e.map((o) => this._getCoder(c.from(o)));
+    return new n(r, "_").defaultValue();
+  }
+  encode(e, r) {
+    e.length !== r.length && i.throwError("types/values length mismatch", m.errors.INVALID_ARGUMENT, {
+      count: { types: e.length, values: r.length },
+      value: { types: e, values: r }
+    });
+    const t = e.map((d) => this._getCoder(c.from(d))), o = new n(t, "_"), s = this._getWriter();
+    return o.encode(s, r), s.data;
+  }
+  decode(e, r, t) {
+    const o = e.map((d) => this._getCoder(c.from(d)));
+    return new n(o, "_").decode(this._getReader(u(r), t));
+  }
+}
+const P = new T();
+export {
+  T as AbiCoder,
+  P as defaultAbiCoder
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.mjs

@@ -0,0 +1,111 @@
+import { hexConcat as g, concat as a, arrayify as n, hexlify as w } from "../../../bytes/lib.esm/index.mjs";
+import { defineReadOnly as i } from "../../../properties/lib.esm/index.mjs";
+import { Logger as d } from "../../../logger/lib.esm/index.mjs";
+import { version as p } from "../_version.mjs";
+import { BigNumber as u } from "../../../bignumber/lib.esm/bignumber.mjs";
+const f = new d(p);
+function L(h) {
+  const t = [], e = function(r, s) {
+    if (Array.isArray(s))
+      for (let l in s) {
+        const o = r.slice();
+        o.push(l);
+        try {
+          e(o, s[l]);
+        } catch (_) {
+          t.push({ path: o, error: _ });
+        }
+      }
+  };
+  return e([], h), t;
+}
+class B {
+  constructor(t, e, r, s) {
+    this.name = t, this.type = e, this.localName = r, this.dynamic = s;
+  }
+  _throwError(t, e) {
+    f.throwArgumentError(t, this.localName, e);
+  }
+}
+class F {
+  constructor(t) {
+    i(this, "wordSize", t || 32), this._data = [], this._dataLength = 0, this._padding = new Uint8Array(t);
+  }
+  get data() {
+    return g(this._data);
+  }
+  get length() {
+    return this._dataLength;
+  }
+  _writeData(t) {
+    return this._data.push(t), this._dataLength += t.length, t.length;
+  }
+  appendWriter(t) {
+    return this._writeData(a(t._data));
+  }
+  // Arrayish items; padded on the right to wordSize
+  writeBytes(t) {
+    let e = n(t);
+    const r = e.length % this.wordSize;
+    return r && (e = a([e, this._padding.slice(r)])), this._writeData(e);
+  }
+  _getValue(t) {
+    let e = n(u.from(t));
+    return e.length > this.wordSize && f.throwError("value out-of-bounds", d.errors.BUFFER_OVERRUN, {
+      length: this.wordSize,
+      offset: e.length
+    }), e.length % this.wordSize && (e = a([this._padding.slice(e.length % this.wordSize), e])), e;
+  }
+  // BigNumberish items; padded on the left to wordSize
+  writeValue(t) {
+    return this._writeData(this._getValue(t));
+  }
+  writeUpdatableValue() {
+    const t = this._data.length;
+    return this._data.push(this._padding), this._dataLength += this.wordSize, (e) => {
+      this._data[t] = this._getValue(e);
+    };
+  }
+}
+class c {
+  constructor(t, e, r, s) {
+    i(this, "_data", n(t)), i(this, "wordSize", e || 32), i(this, "_coerceFunc", r), i(this, "allowLoose", s), this._offset = 0;
+  }
+  get data() {
+    return w(this._data);
+  }
+  get consumed() {
+    return this._offset;
+  }
+  // The default Coerce function
+  static coerce(t, e) {
+    let r = t.match("^u?int([0-9]+)$");
+    return r && parseInt(r[1]) <= 48 && (e = e.toNumber()), e;
+  }
+  coerce(t, e) {
+    return this._coerceFunc ? this._coerceFunc(t, e) : c.coerce(t, e);
+  }
+  _peekBytes(t, e, r) {
+    let s = Math.ceil(e / this.wordSize) * this.wordSize;
+    return this._offset + s > this._data.length && (this.allowLoose && r && this._offset + e <= this._data.length ? s = e : f.throwError("data out-of-bounds", d.errors.BUFFER_OVERRUN, {
+      length: this._data.length,
+      offset: this._offset + s
+    })), this._data.slice(this._offset, this._offset + s);
+  }
+  subReader(t) {
+    return new c(this._data.slice(this._offset + t), this.wordSize, this._coerceFunc, this.allowLoose);
+  }
+  readBytes(t, e) {
+    let r = this._peekBytes(0, t, !!e);
+    return this._offset += r.length, r.slice(0, t);
+  }
+  readValue() {
+    return u.from(this.readBytes(this.wordSize));
+  }
+}
+export {
+  B as Coder,
+  c as Reader,
+  F as Writer,
+  L as checkResultErrors
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abi/lib.esm/coders/address.mjs

@@ -0,0 +1,25 @@
+import { getAddress as t } from "../../../address/lib.esm/index.mjs";
+import { hexZeroPad as d } from "../../../bytes/lib.esm/index.mjs";
+import { Coder as s } from "./abstract-coder.mjs";
+class i extends s {
+  constructor(r) {
+    super("address", "address", r, !1);
+  }
+  defaultValue() {
+    return "0x0000000000000000000000000000000000000000";
+  }
+  encode(r, e) {
+    try {
+      e = t(e);
+    } catch (o) {
+      this._throwError(o.message, e);
+    }
+    return r.writeValue(e);
+  }
+  decode(r) {
+    return t(d(r.readValue().toHexString(), 20));
+  }
+}
+export {
+  i as AddressCoder
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abi/lib.esm/coders/anonymous.mjs

@@ -0,0 +1,18 @@
+import { Coder as r } from "./abstract-coder.mjs";
+class n extends r {
+  constructor(e) {
+    super(e.name, e.type, void 0, e.dynamic), this.coder = e;
+  }
+  defaultValue() {
+    return this.coder.defaultValue();
+  }
+  encode(e, d) {
+    return this.coder.encode(e, d);
+  }
+  decode(e) {
+    return this.coder.decode(e);
+  }
+}
+export {
+  n as AnonymousCoder
+};