@hinkal/common 0.0.115 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/build/slip10.mjs

@@ -0,0 +1,150 @@
+import { commonjsGlobal as _ } from "../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as v } from "../../../../../../../../../_virtual/slip10.mjs";
+import "../../encoding/build/index.mjs";
+import "../../math/build/index.mjs";
+import { b as H } from "../../../bn.js/lib/bn.mjs";
+import "../../../elliptic/lib/elliptic.mjs";
+import "./hmac.mjs";
+import "./sha.mjs";
+import { __exports as U } from "../../../../../../../../../_virtual/elliptic.mjs";
+import { __exports as T } from "../../../../../../../../../_virtual/index54.mjs";
+import { __exports as D } from "../../../../../../../../../_virtual/index55.mjs";
+import { __exports as P } from "../../../../../../../../../_virtual/hmac.mjs";
+import { __exports as G } from "../../../../../../../../../_virtual/sha.mjs";
+(function(s) {
+  var f = _ && _.__importDefault || function(n) {
+    return n && n.__esModule ? n : { default: n };
+  };
+  Object.defineProperty(s, "__esModule", { value: !0 }), s.stringToPath = s.pathToString = s.Slip10 = s.Slip10RawIndex = s.slip10CurveFromString = s.Slip10Curve = void 0;
+  const w = D, F = T, u = f(H), E = f(U), h = P, m = G;
+  var a;
+  (function(n) {
+    n.Secp256k1 = "Bitcoin seed", n.Ed25519 = "ed25519 seed";
+  })(a = s.Slip10Curve || (s.Slip10Curve = {}));
+  function y(n) {
+    switch (n) {
+      case a.Ed25519:
+        return a.Ed25519;
+      case a.Secp256k1:
+        return a.Secp256k1;
+      default:
+        throw new Error(`Unknown curve string: '${n}'`);
+    }
+  }
+  s.slip10CurveFromString = y;
+  class l extends F.Uint32 {
+    static hardened(t) {
+      return new l(t + 2 ** 31);
+    }
+    static normal(t) {
+      return new l(t);
+    }
+    isHardened() {
+      return this.data >= 2 ** 31;
+    }
+  }
+  s.Slip10RawIndex = l;
+  const b = new E.default.ec("secp256k1");
+  class p {
+    static derivePath(t, e, r) {
+      let i = this.master(t, e);
+      for (const o of r)
+        i = this.child(t, i.privkey, i.chainCode, o);
+      return i;
+    }
+    static master(t, e) {
+      const r = new h.Hmac(m.Sha512, (0, w.toAscii)(t)).update(e).digest(), i = r.slice(0, 32), o = r.slice(32, 64);
+      return t !== a.Ed25519 && (this.isZero(i) || this.isGteN(t, i)) ? this.master(t, r) : {
+        chainCode: o,
+        privkey: i
+      };
+    }
+    static child(t, e, r, i) {
+      let o;
+      if (i.isHardened()) {
+        const c = new Uint8Array([0, ...e, ...i.toBytesBigEndian()]);
+        o = new h.Hmac(m.Sha512, r).update(c).digest();
+      } else {
+        if (t === a.Ed25519)
+          throw new Error("Normal keys are not allowed with ed25519");
+        {
+          const c = new Uint8Array([
+            ...p.serializedPoint(t, new u.default(e)),
+            ...i.toBytesBigEndian()
+          ]);
+          o = new h.Hmac(m.Sha512, r).update(c).digest();
+        }
+      }
+      return this.childImpl(t, e, r, i, o);
+    }
+    /**
+     * Implementation of ser_P(point(k_par)) from BIP-0032
+     *
+     * @see https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+     */
+    static serializedPoint(t, e) {
+      switch (t) {
+        case a.Secp256k1:
+          return (0, w.fromHex)(b.g.mul(e).encodeCompressed("hex"));
+        default:
+          throw new Error("curve not supported");
+      }
+    }
+    static childImpl(t, e, r, i, o) {
+      const c = o.slice(0, 32), d = o.slice(32, 64), g = d;
+      if (t === a.Ed25519)
+        return {
+          chainCode: g,
+          privkey: c
+        };
+      const C = this.n(t), B = new u.default(c).add(new u.default(e)).mod(C), S = Uint8Array.from(B.toArray("be", 32));
+      if (this.isGteN(t, c) || this.isZero(S)) {
+        const N = new h.Hmac(m.Sha512, r).update(new Uint8Array([1, ...d, ...i.toBytesBigEndian()])).digest();
+        return this.childImpl(t, e, r, i, N);
+      }
+      return {
+        chainCode: g,
+        privkey: S
+      };
+    }
+    static isZero(t) {
+      return t.every((e) => e === 0);
+    }
+    static isGteN(t, e) {
+      return new u.default(e).gte(this.n(t));
+    }
+    static n(t) {
+      switch (t) {
+        case a.Secp256k1:
+          return new u.default("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16);
+        default:
+          throw new Error("curve not supported");
+      }
+    }
+  }
+  s.Slip10 = p;
+  function A(n) {
+    return n.reduce((t, e) => {
+      const r = e.isHardened() ? `${e.toNumber() - 2147483648}'` : e.toString();
+      return t + "/" + r;
+    }, "m");
+  }
+  s.pathToString = A;
+  function k(n) {
+    if (!n.startsWith("m"))
+      throw new Error("Path string must start with 'm'");
+    let t = n.slice(1);
+    const e = new Array();
+    for (; t; ) {
+      const r = t.match(/^\/([0-9]+)('?)/);
+      if (!r)
+        throw new Error("Syntax error while reading path component");
+      const [i, o, c] = r, d = F.Uint53.fromString(o).toNumber();
+      if (d >= 2 ** 31)
+        throw new Error("Component value too high. Must not exceed 2**31-1.");
+      c ? e.push(l.hardened(d)) : e.push(l.normal(d)), t = t.slice(i.length);
+    }
+    return e;
+  }
+  s.stringToPath = k;
+})(v);

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

@@ -0,0 +1,10 @@
+import { __exports as e } from "../../../../../../../../../_virtual/utils4.mjs";
+Object.defineProperty(e, "__esModule", { value: !0 });
+e.toRealUint8Array = void 0;
+function t(r) {
+  return r instanceof Uint8Array ? r : Uint8Array.from(r);
+}
+e.toRealUint8Array = t;
+export {
+  e as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/node_modules/@noble/hashes/_assert.mjs

@@ -0,0 +1,46 @@
+import { __exports as t } from "../../../../../../../../../../../_virtual/_assert.mjs";
+Object.defineProperty(t, "__esModule", { value: !0 });
+t.output = t.exists = t.hash = t.bytes = t.bool = t.number = t.isBytes = void 0;
+function r(e) {
+  if (!Number.isSafeInteger(e) || e < 0)
+    throw new Error(`positive integer expected, not ${e}`);
+}
+t.number = r;
+function i(e) {
+  if (typeof e != "boolean")
+    throw new Error(`boolean expected, not ${e}`);
+}
+t.bool = i;
+function u(e) {
+  return e instanceof Uint8Array || e != null && typeof e == "object" && e.constructor.name === "Uint8Array";
+}
+t.isBytes = u;
+function n(e, ...o) {
+  if (!u(e))
+    throw new Error("Uint8Array expected");
+  if (o.length > 0 && !o.includes(e.length))
+    throw new Error(`Uint8Array expected of length ${o}, not of length=${e.length}`);
+}
+t.bytes = n;
+function f(e) {
+  if (typeof e != "function" || typeof e.create != "function")
+    throw new Error("Hash should be wrapped by utils.wrapConstructor");
+  r(e.outputLen), r(e.blockLen);
+}
+t.hash = f;
+function a(e, o = !0) {
+  if (e.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (o && e.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+t.exists = a;
+function c(e, o) {
+  n(e);
+  const s = o.outputLen;
+  if (e.length < s)
+    throw new Error(`digestInto() expects output buffer of length at least ${s}`);
+}
+t.output = c;
+const h = { number: r, bool: i, bytes: n, hash: f, exists: a, output: c };
+t.default = h;

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/node_modules/@noble/hashes/_md.mjs

@@ -0,0 +1,72 @@
+import { __exports as u } from "../../../../../../../../../../../_virtual/_md.mjs";
+import "./_assert.mjs";
+import "./utils.mjs";
+import { __exports as g } from "../../../../../../../../../../../_virtual/_assert.mjs";
+import { __exports as _ } from "../../../../../../../../../../../_virtual/utils5.mjs";
+Object.defineProperty(u, "__esModule", { value: !0 });
+u.HashMD = u.Maj = u.Chi = void 0;
+const a = g, p = _;
+function b(o, t, s, i) {
+  if (typeof o.setBigUint64 == "function")
+    return o.setBigUint64(t, s, i);
+  const n = BigInt(32), r = BigInt(4294967295), e = Number(s >> n & r), h = Number(s & r), c = i ? 4 : 0, l = i ? 0 : 4;
+  o.setUint32(t + c, e, i), o.setUint32(t + l, h, i);
+}
+const m = (o, t, s) => o & t ^ ~o & s;
+u.Chi = m;
+const w = (o, t, s) => o & t ^ o & s ^ t & s;
+u.Maj = w;
+class x extends p.Hash {
+  constructor(t, s, i, n) {
+    super(), this.blockLen = t, this.outputLen = s, this.padOffset = i, this.isLE = n, this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.buffer = new Uint8Array(t), this.view = (0, p.createView)(this.buffer);
+  }
+  update(t) {
+    (0, a.exists)(this);
+    const { view: s, buffer: i, blockLen: n } = this;
+    t = (0, p.toBytes)(t);
+    const r = t.length;
+    for (let e = 0; e < r; ) {
+      const h = Math.min(n - this.pos, r - e);
+      if (h === n) {
+        const c = (0, p.createView)(t);
+        for (; n <= r - e; e += n)
+          this.process(c, e);
+        continue;
+      }
+      i.set(t.subarray(e, e + h), this.pos), this.pos += h, e += h, this.pos === n && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    (0, a.exists)(this), (0, a.output)(t, this), this.finished = !0;
+    const { buffer: s, view: i, blockLen: n, isLE: r } = this;
+    let { pos: e } = this;
+    s[e++] = 128, this.buffer.subarray(e).fill(0), this.padOffset > n - e && (this.process(i, 0), e = 0);
+    for (let f = e; f < n; f++)
+      s[f] = 0;
+    b(i, n - 8, BigInt(this.length * 8), r), this.process(i, 0);
+    const h = (0, p.createView)(t), c = this.outputLen;
+    if (c % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const l = c / 4, d = this.get();
+    if (l > d.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let f = 0; f < l; f++)
+      h.setUint32(4 * f, d[f], r);
+  }
+  digest() {
+    const { buffer: t, outputLen: s } = this;
+    this.digestInto(t);
+    const i = t.slice(0, s);
+    return this.destroy(), i;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: s, buffer: i, length: n, finished: r, destroyed: e, pos: h } = this;
+    return t.length = n, t.pos = h, t.finished = r, t.destroyed = e, n % s && t.buffer.set(i), t;
+  }
+}
+u.HashMD = x;
+export {
+  u as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/node_modules/@noble/hashes/_u64.mjs

@@ -0,0 +1,85 @@
+import { __exports as r } from "../../../../../../../../../../../_virtual/_u64.mjs";
+Object.defineProperty(r, "__esModule", { value: !0 });
+r.add5L = r.add5H = r.add4H = r.add4L = r.add3H = r.add3L = r.add = r.rotlBL = r.rotlBH = r.rotlSL = r.rotlSH = r.rotr32L = r.rotr32H = r.rotrBL = r.rotrBH = r.rotrSL = r.rotrSH = r.shrSL = r.shrSH = r.toBig = r.split = r.fromBig = void 0;
+const a = /* @__PURE__ */ BigInt(2 ** 32 - 1), e = /* @__PURE__ */ BigInt(32);
+function H(t, d = !1) {
+  return d ? { h: Number(t & a), l: Number(t >> e & a) } : { h: Number(t >> e & a) | 0, l: Number(t & a) | 0 };
+}
+r.fromBig = H;
+function L(t, d = !1) {
+  let o = new Uint32Array(t.length), n = new Uint32Array(t.length);
+  for (let l = 0; l < t.length; l++) {
+    const { h: c, l: j } = H(t[l], d);
+    [o[l], n[l]] = [c, j];
+  }
+  return [o, n];
+}
+r.split = L;
+const s = (t, d) => BigInt(t >>> 0) << e | BigInt(d >>> 0);
+r.toBig = s;
+const i = (t, d, o) => t >>> o;
+r.shrSH = i;
+const B = (t, d, o) => t << 32 - o | d >>> o;
+r.shrSL = B;
+const S = (t, d, o) => t >>> o | d << 32 - o;
+r.rotrSH = S;
+const u = (t, d, o) => t << 32 - o | d >>> o;
+r.rotrSL = u;
+const h = (t, d, o) => t << 64 - o | d >>> o - 32;
+r.rotrBH = h;
+const f = (t, d, o) => t >>> o - 32 | d << 64 - o;
+r.rotrBL = f;
+const g = (t, d) => d;
+r.rotr32H = g;
+const _ = (t, d) => t;
+r.rotr32L = _;
+const m = (t, d, o) => t << o | d >>> 32 - o;
+r.rotlSH = m;
+const p = (t, d, o) => d << o | t >>> 32 - o;
+r.rotlSL = p;
+const b = (t, d, o) => d << o - 32 | t >>> 64 - o;
+r.rotlBH = b;
+const A = (t, d, o) => t << o - 32 | d >>> 64 - o;
+r.rotlBL = A;
+function I(t, d, o, n) {
+  const l = (d >>> 0) + (n >>> 0);
+  return { h: t + o + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+r.add = I;
+const N = (t, d, o) => (t >>> 0) + (d >>> 0) + (o >>> 0);
+r.add3L = N;
+const y = (t, d, o, n) => d + o + n + (t / 2 ** 32 | 0) | 0;
+r.add3H = y;
+const U = (t, d, o, n) => (t >>> 0) + (d >>> 0) + (o >>> 0) + (n >>> 0);
+r.add4L = U;
+const v = (t, d, o, n, l) => d + o + n + l + (t / 2 ** 32 | 0) | 0;
+r.add4H = v;
+const w = (t, d, o, n, l) => (t >>> 0) + (d >>> 0) + (o >>> 0) + (n >>> 0) + (l >>> 0);
+r.add5L = w;
+const M = (t, d, o, n, l, c) => d + o + n + l + c + (t / 2 ** 32 | 0) | 0;
+r.add5H = M;
+const x = {
+  fromBig: H,
+  split: L,
+  toBig: s,
+  shrSH: i,
+  shrSL: B,
+  rotrSH: S,
+  rotrSL: u,
+  rotrBH: h,
+  rotrBL: f,
+  rotr32H: g,
+  rotr32L: _,
+  rotlSH: m,
+  rotlSL: p,
+  rotlBH: b,
+  rotlBL: A,
+  add: I,
+  add3L: N,
+  add3H: y,
+  add4L: U,
+  add4H: v,
+  add5H: M,
+  add5L: w
+};
+r.default = x;

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/node_modules/@noble/hashes/crypto.mjs

@@ -0,0 +1,7 @@
+import { __exports as o } from "../../../../../../../../../../../_virtual/crypto.mjs";
+Object.defineProperty(o, "__esModule", { value: !0 });
+o.crypto = void 0;
+o.crypto = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+export {
+  o as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/node_modules/@noble/hashes/hmac.mjs

@@ -0,0 +1,47 @@
+import { __exports as H } from "../../../../../../../../../../../_virtual/hmac2.mjs";
+import "./_assert.mjs";
+import "./utils.mjs";
+import { __exports as p } from "../../../../../../../../../../../_virtual/_assert.mjs";
+import { __exports as f } from "../../../../../../../../../../../_virtual/utils5.mjs";
+(function(i) {
+  Object.defineProperty(i, "__esModule", { value: !0 }), i.hmac = i.HMAC = void 0;
+  const o = p, d = f;
+  class c extends d.Hash {
+    constructor(t, h) {
+      super(), this.finished = !1, this.destroyed = !1, (0, o.hash)(t);
+      const n = (0, d.toBytes)(h);
+      if (this.iHash = t.create(), 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 r = this.blockLen, s = new Uint8Array(r);
+      s.set(n.length > r ? t.create().update(n).digest() : n);
+      for (let e = 0; e < s.length; e++)
+        s[e] ^= 54;
+      this.iHash.update(s), this.oHash = t.create();
+      for (let e = 0; e < s.length; e++)
+        s[e] ^= 106;
+      this.oHash.update(s), s.fill(0);
+    }
+    update(t) {
+      return (0, o.exists)(this), this.iHash.update(t), this;
+    }
+    digestInto(t) {
+      (0, o.exists)(this), (0, o.bytes)(t, this.outputLen), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
+    }
+    digest() {
+      const t = new Uint8Array(this.oHash.outputLen);
+      return this.digestInto(t), t;
+    }
+    _cloneInto(t) {
+      t || (t = Object.create(Object.getPrototypeOf(this), {}));
+      const { oHash: h, iHash: n, finished: r, destroyed: s, blockLen: e, outputLen: l } = this;
+      return t = t, t.finished = r, t.destroyed = s, t.blockLen = e, t.outputLen = l, t.oHash = h._cloneInto(t.oHash), t.iHash = n._cloneInto(t.iHash), t;
+    }
+    destroy() {
+      this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+    }
+  }
+  i.HMAC = c;
+  const u = (a, t, h) => new c(a, t).update(h).digest();
+  i.hmac = u, i.hmac.create = (a, t) => new c(a, t);
+})(H);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/node_modules/@noble/hashes/pbkdf2.mjs

@@ -0,0 +1,55 @@
+import { __exports as w } from "../../../../../../../../../../../_virtual/pbkdf22.mjs";
+import "./_assert.mjs";
+import "./hmac.mjs";
+import "./utils.mjs";
+import { __exports as g } from "../../../../../../../../../../../_virtual/utils5.mjs";
+import { __exports as A } from "../../../../../../../../../../../_virtual/_assert.mjs";
+import { __exports as P } from "../../../../../../../../../../../_virtual/hmac2.mjs";
+Object.defineProperty(w, "__esModule", { value: !0 });
+w.pbkdf2Async = w.pbkdf2 = void 0;
+const I = A, F = P, m = g;
+function L(i, d, f, u) {
+  (0, I.hash)(i);
+  const l = (0, m.checkOpts)({ dkLen: 32, asyncTick: 10 }, u), { c: y, dkLen: p, asyncTick: t } = l;
+  if ((0, I.number)(y), (0, I.number)(p), (0, I.number)(t), y < 1)
+    throw new Error("PBKDF2: iterations (c) should be >= 1");
+  const e = (0, m.toBytes)(d), o = (0, m.toBytes)(f), s = new Uint8Array(p), _ = F.hmac.create(i, e), n = _._cloneInto().update(o);
+  return { c: y, dkLen: p, asyncTick: t, DK: s, PRF: _, PRFSalt: n };
+}
+function h(i, d, f, u, l) {
+  return i.destroy(), d.destroy(), u && u.destroy(), l.fill(0), f;
+}
+function R(i, d, f, u) {
+  const { c: l, dkLen: y, DK: p, PRF: t, PRFSalt: e } = L(i, d, f, u);
+  let o;
+  const s = new Uint8Array(4), _ = (0, m.createView)(s), n = new Uint8Array(t.outputLen);
+  for (let r = 1, b = 0; b < y; r++, b += t.outputLen) {
+    const c = p.subarray(b, b + t.outputLen);
+    _.setInt32(0, r, !1), (o = e._cloneInto(o)).update(s).digestInto(n), c.set(n.subarray(0, c.length));
+    for (let k = 1; k < l; k++) {
+      t._cloneInto(o).update(n).digestInto(n);
+      for (let a = 0; a < c.length; a++)
+        c[a] ^= n[a];
+    }
+  }
+  return h(t, e, p, o, n);
+}
+w.pbkdf2 = R;
+async function x(i, d, f, u) {
+  const { c: l, dkLen: y, asyncTick: p, DK: t, PRF: e, PRFSalt: o } = L(i, d, f, u);
+  let s;
+  const _ = new Uint8Array(4), n = (0, m.createView)(_), r = new Uint8Array(e.outputLen);
+  for (let b = 1, c = 0; c < y; b++, c += e.outputLen) {
+    const k = t.subarray(c, c + e.outputLen);
+    n.setInt32(0, b, !1), (s = o._cloneInto(s)).update(_).digestInto(r), k.set(r.subarray(0, k.length)), await (0, m.asyncLoop)(l - 1, p, () => {
+      e._cloneInto(s).update(r).digestInto(r);
+      for (let a = 0; a < k.length; a++)
+        k[a] ^= r[a];
+    });
+  }
+  return h(e, o, t, s, r);
+}
+w.pbkdf2Async = x;
+export {
+  w as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/node_modules/@noble/hashes/ripemd160.mjs

@@ -0,0 +1,75 @@
+import { __exports as d } from "../../../../../../../../../../../_virtual/ripemd160.mjs";
+import "./_md.mjs";
+import "./utils.mjs";
+import { __exports as K } from "../../../../../../../../../../../_virtual/utils5.mjs";
+import { __exports as L } from "../../../../../../../../../../../_virtual/_md.mjs";
+Object.defineProperty(d, "__esModule", { value: !0 });
+d.ripemd160 = d.RIPEMD160 = void 0;
+const B = L, f = K, F = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]), R = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((s, t) => t)), G = /* @__PURE__ */ R.map((s) => (9 * s + 5) % 16);
+let w = [R], U = [G];
+for (let s = 0; s < 4; s++)
+  for (let t of [w, U])
+    t.push(t[s].map((r) => F[r]));
+const y = /* @__PURE__ */ [
+  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
+  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
+  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
+  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
+  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
+].map((s) => new Uint8Array(s)), H = /* @__PURE__ */ w.map((s, t) => s.map((r) => y[t][r])), O = /* @__PURE__ */ U.map((s, t) => s.map((r) => y[t][r])), g = /* @__PURE__ */ new Uint32Array([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), k = /* @__PURE__ */ new Uint32Array([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function A(s, t, r, e) {
+  return s === 0 ? t ^ r ^ e : s === 1 ? t & r | ~t & e : s === 2 ? (t | ~r) ^ e : s === 3 ? t & e | r & ~e : t ^ (r | ~e);
+}
+const _ = /* @__PURE__ */ new Uint32Array(16);
+class M extends B.HashMD {
+  constructor() {
+    super(64, 20, 8, !0), this.h0 = 1732584193, this.h1 = -271733879, this.h2 = -1732584194, this.h3 = 271733878, this.h4 = -1009589776;
+  }
+  get() {
+    const { h0: t, h1: r, h2: e, h3: n, h4: h } = this;
+    return [t, r, e, n, h];
+  }
+  set(t, r, e, n, h) {
+    this.h0 = t | 0, this.h1 = r | 0, this.h2 = e | 0, this.h3 = n | 0, this.h4 = h | 0;
+  }
+  process(t, r) {
+    for (let i = 0; i < 16; i++, r += 4)
+      _[i] = t.getUint32(r, !0);
+    let e = this.h0 | 0, n = e, h = this.h1 | 0, p = h, l = this.h2 | 0, m = l, a = this.h3 | 0, u = a, c = this.h4 | 0, x = c;
+    for (let i = 0; i < 5; i++) {
+      const P = 4 - i, j = g[i], D = k[i], I = w[i], E = U[i], v = H[i], C = O[i];
+      for (let o = 0; o < 16; o++) {
+        const b = (0, f.rotl)(e + A(i, h, l, a) + _[I[o]] + j, v[o]) + c | 0;
+        e = c, c = a, a = (0, f.rotl)(l, 10) | 0, l = h, h = b;
+      }
+      for (let o = 0; o < 16; o++) {
+        const b = (0, f.rotl)(n + A(P, p, m, u) + _[E[o]] + D, C[o]) + x | 0;
+        n = x, x = u, u = (0, f.rotl)(m, 10) | 0, m = p, p = b;
+      }
+    }
+    this.set(this.h1 + l + u | 0, this.h2 + a + x | 0, this.h3 + c + n | 0, this.h4 + e + p | 0, this.h0 + h + m | 0);
+  }
+  roundClean() {
+    _.fill(0);
+  }
+  destroy() {
+    this.destroyed = !0, this.buffer.fill(0), this.set(0, 0, 0, 0, 0);
+  }
+}
+d.RIPEMD160 = M;
+d.ripemd160 = (0, f.wrapConstructor)(() => new M());
+export {
+  d as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/crypto/node_modules/@noble/hashes/sha256.mjs

@@ -0,0 +1,125 @@
+import { __exports as _ } from "../../../../../../../../../../../_virtual/sha256.mjs";
+import "./_md.mjs";
+import "./utils.mjs";
+import { __exports as w } from "../../../../../../../../../../../_virtual/utils5.mjs";
+import { __exports as D } from "../../../../../../../../../../../_virtual/_md.mjs";
+Object.defineProperty(_, "__esModule", { value: !0 });
+_.sha224 = _.sha256 = void 0;
+const A = D, c = w, B = /* @__PURE__ */ new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), f = /* @__PURE__ */ new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), o = /* @__PURE__ */ new Uint32Array(64);
+class H extends A.HashMD {
+  constructor() {
+    super(64, 32, 8, !1), this.A = f[0] | 0, this.B = f[1] | 0, this.C = f[2] | 0, this.D = f[3] | 0, this.E = f[4] | 0, this.F = f[5] | 0, this.G = f[6] | 0, this.H = f[7] | 0;
+  }
+  get() {
+    const { A: n, B: h, C: s, D: e, E: a, F: i, G: x, H: r } = this;
+    return [n, h, s, e, a, i, x, r];
+  }
+  // prettier-ignore
+  set(n, h, s, e, a, i, x, r) {
+    this.A = n | 0, this.B = h | 0, this.C = s | 0, this.D = e | 0, this.E = a | 0, this.F = i | 0, this.G = x | 0, this.H = r | 0;
+  }
+  process(n, h) {
+    for (let t = 0; t < 16; t++, h += 4)
+      o[t] = n.getUint32(h, !1);
+    for (let t = 16; t < 64; t++) {
+      const u = o[t - 15], d = o[t - 2], m = (0, c.rotr)(u, 7) ^ (0, c.rotr)(u, 18) ^ u >>> 3, p = (0, c.rotr)(d, 17) ^ (0, c.rotr)(d, 19) ^ d >>> 10;
+      o[t] = p + o[t - 7] + m + o[t - 16] | 0;
+    }
+    let { A: s, B: e, C: a, D: i, E: x, F: r, G: b, H: l } = this;
+    for (let t = 0; t < 64; t++) {
+      const u = (0, c.rotr)(x, 6) ^ (0, c.rotr)(x, 11) ^ (0, c.rotr)(x, 25), d = l + u + (0, A.Chi)(x, r, b) + B[t] + o[t] | 0, p = ((0, c.rotr)(s, 2) ^ (0, c.rotr)(s, 13) ^ (0, c.rotr)(s, 22)) + (0, A.Maj)(s, e, a) | 0;
+      l = b, b = r, r = x, x = i + d | 0, i = a, a = e, e = s, s = d + p | 0;
+    }
+    s = s + this.A | 0, e = e + this.B | 0, a = a + this.C | 0, i = i + this.D | 0, x = x + this.E | 0, r = r + this.F | 0, b = b + this.G | 0, l = l + this.H | 0, this.set(s, e, a, i, x, r, b, l);
+  }
+  roundClean() {
+    o.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), this.buffer.fill(0);
+  }
+}
+class E extends H {
+  constructor() {
+    super(), this.A = -1056596264, this.B = 914150663, this.C = 812702999, this.D = -150054599, this.E = -4191439, this.F = 1750603025, this.G = 1694076839, this.H = -1090891868, this.outputLen = 28;
+  }
+}
+_.sha256 = (0, c.wrapConstructor)(() => new H());
+_.sha224 = (0, c.wrapConstructor)(() => new E());
+export {
+  _ as default
+};