@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@confio/ics23/build/ics23.mjs

@@ -0,0 +1,65 @@
+import { __exports as n } from "../../../../../../../../../_virtual/ics23.mjs";
+import "./compress.mjs";
+import "./proofs.mjs";
+import "./specs.mjs";
+import { __exports as b } from "../../../../../../../../../_virtual/compress.mjs";
+import { __exports as p } from "../../../../../../../../../_virtual/proofs.mjs";
+import { __exports as y } from "../../../../../../../../../_virtual/specs.mjs";
+Object.defineProperty(n, "__esModule", { value: !0 });
+n.batchVerifyNonMembership = n.batchVerifyMembership = n.verifyNonMembership = n.verifyMembership = void 0;
+const c = b, u = p, m = y;
+function a(r, s, t, e, o) {
+  const i = (0, c.decompress)(r), f = _(i, e);
+  if (!f)
+    return !1;
+  try {
+    return (0, u.verifyExistence)(f, s, t, e, o), !0;
+  } catch {
+    return !1;
+  }
+}
+n.verifyMembership = a;
+function h(r, s, t, e) {
+  const o = (0, c.decompress)(r), i = d(o, e);
+  if (!i)
+    return !1;
+  try {
+    return (0, u.verifyNonExistence)(i, s, t, e), !0;
+  } catch {
+    return !1;
+  }
+}
+n.verifyNonMembership = h;
+function l(r, s, t, e) {
+  const o = (0, c.decompress)(r);
+  for (const [i, f] of e.entries())
+    if (!a(o, s, t, i, f))
+      return !1;
+  return !0;
+}
+n.batchVerifyMembership = l;
+function x(r, s, t, e) {
+  const o = (0, c.decompress)(r);
+  for (const i of e)
+    if (!h(o, s, t, i))
+      return !1;
+  return !0;
+}
+n.batchVerifyNonMembership = x;
+function _(r, s) {
+  const t = (e) => !!e && (0, m.bytesEqual)(s, e.key);
+  if (t(r.exist))
+    return r.exist;
+  if (r.batch)
+    return r.batch.entries.map((e) => e.exist || null).find(t);
+}
+function d(r, s) {
+  const t = (e) => !!e && (!e.left || (0, m.bytesBefore)(e.left.key, s)) && (!e.right || (0, m.bytesBefore)(s, e.right.key));
+  if (t(r.nonexist))
+    return r.nonexist;
+  if (r.batch)
+    return r.batch.entries.map((e) => e.nonexist || null).find(t);
+}
+export {
+  n as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@confio/ics23/build/index.mjs

@@ -0,0 +1,31 @@
+import { __exports as n } from "../../../../../../../../../_virtual/index66.mjs";
+import { c } from "./generated/codecimpl.mjs";
+import "./ics23.mjs";
+import "./proofs.mjs";
+import { __exports as u } from "../../../../../../../../../_virtual/ics23.mjs";
+import { __exports as f } from "../../../../../../../../../_virtual/proofs.mjs";
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.verifyNonExistence = e.verifyExistence = e.tendermintSpec = e.iavlSpec = e.calculateExistenceRoot = e.verifyNonMembership = e.verifyMembership = e.ics23 = void 0;
+  var t = c;
+  Object.defineProperty(e, "ics23", { enumerable: !0, get: function() {
+    return t.ics23;
+  } });
+  var i = u;
+  Object.defineProperty(e, "verifyMembership", { enumerable: !0, get: function() {
+    return i.verifyMembership;
+  } }), Object.defineProperty(e, "verifyNonMembership", { enumerable: !0, get: function() {
+    return i.verifyNonMembership;
+  } });
+  var r = f;
+  Object.defineProperty(e, "calculateExistenceRoot", { enumerable: !0, get: function() {
+    return r.calculateExistenceRoot;
+  } }), Object.defineProperty(e, "iavlSpec", { enumerable: !0, get: function() {
+    return r.iavlSpec;
+  } }), Object.defineProperty(e, "tendermintSpec", { enumerable: !0, get: function() {
+    return r.tendermintSpec;
+  } }), Object.defineProperty(e, "verifyExistence", { enumerable: !0, get: function() {
+    return r.verifyExistence;
+  } }), Object.defineProperty(e, "verifyNonExistence", { enumerable: !0, get: function() {
+    return r.verifyNonExistence;
+  } });
+})(n);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@confio/ics23/build/ops.mjs

@@ -0,0 +1,99 @@
+import { __exports as o } from "../../../../../../../../../_virtual/ops.mjs";
+import "../node_modules/@noble/hashes/ripemd160.mjs";
+import "../node_modules/@noble/hashes/sha256.mjs";
+import "../node_modules/@noble/hashes/sha512.mjs";
+import { c as O } from "./generated/codecimpl.mjs";
+import { __exports as H } from "../../../../../../../../../_virtual/ripemd1602.mjs";
+import { __exports as E } from "../../../../../../../../../_virtual/sha2562.mjs";
+import { __exports as y } from "../../../../../../../../../_virtual/sha5122.mjs";
+Object.defineProperty(o, "__esModule", { value: !0 });
+o.doHash = o.applyInner = o.applyLeaf = void 0;
+const u = H, a = E, l = y, t = O;
+function L(r, n, e) {
+  if (n.length === 0)
+    throw new Error("Missing key");
+  if (e.length === 0)
+    throw new Error("Missing value");
+  const s = _(h(r.prehashKey), f(r.length), n), w = _(h(r.prehashValue), f(r.length), e), g = new Uint8Array([
+    ...c(r.prefix),
+    ...s,
+    ...w
+  ]);
+  return i(h(r.hash), g);
+}
+o.applyLeaf = L;
+function d(r, n) {
+  if (n.length === 0)
+    throw new Error("Inner op needs child value");
+  const e = new Uint8Array([
+    ...c(r.prefix),
+    ...n,
+    ...c(r.suffix)
+  ]);
+  return i(h(r.hash), e);
+}
+o.applyInner = d;
+function p(r, n) {
+  return r ?? n;
+}
+const h = (r) => p(r, t.ics23.HashOp.NO_HASH), f = (r) => p(r, t.ics23.LengthOp.NO_PREFIX), c = (r) => p(r, new Uint8Array([]));
+function _(r, n, e) {
+  const s = m(r, e);
+  return A(n, s);
+}
+function m(r, n) {
+  return r === t.ics23.HashOp.NO_HASH ? n : i(r, n);
+}
+function i(r, n) {
+  switch (r) {
+    case t.ics23.HashOp.SHA256:
+      return (0, a.sha256)(n);
+    case t.ics23.HashOp.SHA512:
+      return (0, l.sha512)(n);
+    case t.ics23.HashOp.RIPEMD160:
+      return (0, u.ripemd160)(n);
+    case t.ics23.HashOp.BITCOIN:
+      return (0, u.ripemd160)((0, a.sha256)(n));
+    case t.ics23.HashOp.SHA512_256:
+      return (0, l.sha512_256)(n);
+  }
+  throw new Error(`Unsupported hashop: ${r}`);
+}
+o.doHash = i;
+function A(r, n) {
+  switch (r) {
+    case t.ics23.LengthOp.NO_PREFIX:
+      return n;
+    case t.ics23.LengthOp.VAR_PROTO:
+      return new Uint8Array([...I(n.length), ...n]);
+    case t.ics23.LengthOp.REQUIRE_32_BYTES:
+      if (n.length !== 32)
+        throw new Error(`Length is ${n.length}, not 32 bytes`);
+      return n;
+    case t.ics23.LengthOp.REQUIRE_64_BYTES:
+      if (n.length !== 64)
+        throw new Error(`Length is ${n.length}, not 64 bytes`);
+      return n;
+    case t.ics23.LengthOp.FIXED32_LITTLE:
+      return new Uint8Array([...U(n.length), ...n]);
+  }
+  throw new Error(`Unsupported lengthop: ${r}`);
+}
+function I(r) {
+  let n = [], e = r;
+  for (; e >= 128; ) {
+    const s = e % 128 + 128;
+    n = [...n, s], e = e / 128;
+  }
+  return n = [...n, e], new Uint8Array(n);
+}
+function U(r) {
+  const n = new Uint8Array(4);
+  let e = r;
+  for (let s = n.length; s > 0; s--)
+    n[Math.abs(s - n.length)] = e % 256, e = Math.floor(e / 256);
+  return n;
+}
+export {
+  o as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@confio/ics23/build/proofs.mjs

@@ -0,0 +1,152 @@
+import { __exports as h } from "../../../../../../../../../_virtual/proofs.mjs";
+import { c as w } from "./generated/codecimpl.mjs";
+import "./ops.mjs";
+import "./specs.mjs";
+import { __exports as E } from "../../../../../../../../../_virtual/ops.mjs";
+import { __exports as O } from "../../../../../../../../../_virtual/specs.mjs";
+Object.defineProperty(h, "__esModule", { value: !0 });
+h.ensureLeftNeighbor = h.ensureSpec = h.calculateExistenceRoot = h.verifyNonExistence = h.verifyExistence = h.smtSpec = h.tendermintSpec = h.iavlSpec = void 0;
+const f = w, p = E, a = O;
+h.iavlSpec = {
+  leafSpec: {
+    prefix: Uint8Array.from([0]),
+    hash: f.ics23.HashOp.SHA256,
+    prehashValue: f.ics23.HashOp.SHA256,
+    prehashKey: f.ics23.HashOp.NO_HASH,
+    length: f.ics23.LengthOp.VAR_PROTO
+  },
+  innerSpec: {
+    childOrder: [0, 1],
+    minPrefixLength: 4,
+    maxPrefixLength: 12,
+    childSize: 33,
+    hash: f.ics23.HashOp.SHA256
+  }
+};
+h.tendermintSpec = {
+  leafSpec: {
+    prefix: Uint8Array.from([0]),
+    hash: f.ics23.HashOp.SHA256,
+    prehashValue: f.ics23.HashOp.SHA256,
+    prehashKey: f.ics23.HashOp.NO_HASH,
+    length: f.ics23.LengthOp.VAR_PROTO
+  },
+  innerSpec: {
+    childOrder: [0, 1],
+    minPrefixLength: 1,
+    maxPrefixLength: 1,
+    childSize: 32,
+    hash: f.ics23.HashOp.SHA256
+  }
+};
+h.smtSpec = {
+  leafSpec: {
+    hash: f.ics23.HashOp.SHA256,
+    prehashKey: f.ics23.HashOp.NO_HASH,
+    prehashValue: f.ics23.HashOp.SHA256,
+    length: f.ics23.LengthOp.NO_PREFIX,
+    prefix: Uint8Array.from([0])
+  },
+  innerSpec: {
+    childOrder: [0, 1],
+    childSize: 32,
+    minPrefixLength: 1,
+    maxPrefixLength: 1,
+    emptyChild: new Uint8Array(32),
+    hash: f.ics23.HashOp.SHA256
+  },
+  maxDepth: 256
+};
+function o(e, t, n, i, r) {
+  m(e, t);
+  const s = d(e);
+  (0, a.ensureBytesEqual)(s, n), (0, a.ensureBytesEqual)(i, e.key), (0, a.ensureBytesEqual)(r, e.value);
+}
+h.verifyExistence = o;
+function H(e, t, n, i) {
+  let r, s;
+  if (e.left && (o(e.left, t, n, e.left.key, e.left.value), r = e.left.key), e.right && (o(e.right, t, n, e.right.key, e.right.value), s = e.right.key), !r && !s)
+    throw new Error("neither left nor right proof defined");
+  if (r && (0, a.ensureBytesBefore)(r, i), s && (0, a.ensureBytesBefore)(i, s), !t.innerSpec)
+    throw new Error("no inner spec");
+  r ? s ? y(t.innerSpec, e.left.path, e.right.path) : S(t.innerSpec, e.left.path) : g(t.innerSpec, e.right.path);
+}
+h.verifyNonExistence = H;
+function d(e) {
+  if (!e.key || !e.value)
+    throw new Error("Existence proof needs key and value set");
+  if (!e.leaf)
+    throw new Error("Existence proof must start with a leaf operation");
+  const t = e.path || [];
+  let n = (0, p.applyLeaf)(e.leaf, e.key, e.value);
+  for (const i of t)
+    n = (0, p.applyInner)(i, n);
+  return n;
+}
+h.calculateExistenceRoot = d;
+function m(e, t) {
+  if (!e.leaf)
+    throw new Error("Existence proof must start with a leaf operation");
+  if (!t.leafSpec)
+    throw new Error("Spec must include leafSpec");
+  if (!t.innerSpec)
+    throw new Error("Spec must include innerSpec");
+  (0, a.ensureLeaf)(e.leaf, t.leafSpec);
+  const n = e.path || [];
+  if (t.minDepth && n.length < t.minDepth)
+    throw new Error(`Too few inner nodes ${n.length}`);
+  if (t.maxDepth && n.length > t.maxDepth)
+    throw new Error(`Too many inner nodes ${n.length}`);
+  for (const i of n)
+    (0, a.ensureInner)(i, t.leafSpec.prefix, t.innerSpec);
+}
+h.ensureSpec = m;
+function g(e, t) {
+  const { minPrefix: n, maxPrefix: i, suffix: r } = u(e, 0);
+  for (const s of t)
+    if (!c(s, n, i, r))
+      throw new Error("Step not leftmost");
+}
+function S(e, t) {
+  const n = e.childOrder.length - 1, { minPrefix: i, maxPrefix: r, suffix: s } = u(e, n);
+  for (const l of t)
+    if (!c(l, i, r, s))
+      throw new Error("Step not leftmost");
+}
+function y(e, t, n) {
+  const i = [...t], r = [...n];
+  let s = i.pop(), l = r.pop();
+  for (; (0, a.bytesEqual)(s.prefix, l.prefix) && (0, a.bytesEqual)(s.suffix, l.suffix); )
+    s = i.pop(), l = r.pop();
+  if (!P(e, s, l))
+    throw new Error("Not left neightbor at first divergent step");
+  S(e, i), g(e, r);
+}
+h.ensureLeftNeighbor = y;
+function P(e, t, n) {
+  const i = x(e, t);
+  return x(e, n) === i + 1;
+}
+function x(e, t) {
+  for (let n = 0; n < e.childOrder.length; n++) {
+    const { minPrefix: i, maxPrefix: r, suffix: s } = u(e, n);
+    if (c(t, i, r, s))
+      return n;
+  }
+  throw new Error("Cannot find any valid spacing for this node");
+}
+function c(e, t, n, i) {
+  return (e.prefix || []).length < t || (e.prefix || []).length > n ? !1 : (e.suffix || []).length === i;
+}
+function u(e, t) {
+  const n = v(e.childOrder, t), i = n * e.childSize, r = i + e.minPrefixLength, s = i + e.maxPrefixLength, l = (e.childOrder.length - 1 - n) * e.childSize;
+  return { minPrefix: r, maxPrefix: s, suffix: l };
+}
+function v(e, t) {
+  if (t < 0 || t >= e.length)
+    throw new Error(`Invalid branch: ${t}`);
+  return e.findIndex((n) => n === t);
+}
+export {
+  h as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@confio/ics23/build/specs.mjs

@@ -0,0 +1,80 @@
+import { __exports as n } from "../../../../../../../../../_virtual/specs.mjs";
+Object.defineProperty(n, "__esModule", { value: !0 });
+n.bytesBefore = n.ensureBytesBefore = n.bytesEqual = n.ensureBytesEqual = n.ensureInner = n.ensureLeaf = void 0;
+function s(e, r) {
+  if (e.hash !== r.hash)
+    throw new Error(`Unexpected hashOp: ${e.hash}`);
+  if (e.prehashKey !== r.prehashKey)
+    throw new Error(`Unexpected prehashKey: ${e.prehashKey}`);
+  if (e.prehashValue !== r.prehashValue)
+    throw new Error(`Unexpected prehashValue: ${e.prehashValue}`);
+  if (e.length !== r.length)
+    throw new Error(`Unexpected length op: ${e.length}`);
+  l(e.prefix, r.prefix);
+}
+n.ensureLeaf = s;
+function i(e, r, t) {
+  if (e.hash !== t.hash)
+    throw new Error(`Unexpected hashOp: ${e.hash}`);
+  if (!e.prefix)
+    throw new Error("No prefix set for inner node");
+  if (g(e.prefix, r))
+    throw new Error("Inner node has leaf prefix");
+  if (e.prefix.length < (t.minPrefixLength || 0))
+    throw new Error(`Prefix too short: ${e.prefix.length} bytes`);
+  const h = (t.childOrder.length - 1) * t.childSize;
+  if (e.prefix.length > (t.maxPrefixLength || 0) + h)
+    throw new Error(`Prefix too long: ${e.prefix.length} bytes`);
+}
+n.ensureInner = i;
+function l(e, r) {
+  if (!(!r || r.length === 0)) {
+    if (!e)
+      throw new Error("Target bytes missing");
+    o(r, e.slice(0, r.length));
+  }
+}
+function o(e, r) {
+  if (e.length !== r.length)
+    throw new Error(`Different lengths ${e.length} vs ${r.length}`);
+  for (let t = 0; t < e.length; t++)
+    if (e[t] !== r[t])
+      throw new Error(`Arrays differ at index ${t}: ${e[t]} vs ${r[t]}`);
+}
+n.ensureBytesEqual = o;
+function u(e, r) {
+  if (e.length !== r.length)
+    return !1;
+  for (let t = 0; t < e.length; t++)
+    if (e[t] !== r[t])
+      return !1;
+  return !0;
+}
+n.bytesEqual = u;
+function g(e, r) {
+  if (!r || r.length === 0 || !e || e.length <= r.length)
+    return !1;
+  for (let t = 0; t < r.length; t++)
+    if (e[t] !== r[t])
+      return !1;
+  throw !0;
+}
+function a(e, r) {
+  if (!f(e, r))
+    throw new Error("first is after last");
+}
+n.ensureBytesBefore = a;
+function f(e, r) {
+  const t = e.length < r.length ? e.length : r.length;
+  for (let h = 0; h < t; h++) {
+    if (e[h] < r[h])
+      return !0;
+    if (e[h] > r[h])
+      return !1;
+  }
+  return e.length < r.length;
+}
+n.bytesBefore = f;
+export {
+  n as default
+};

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

@@ -0,0 +1,46 @@
+import { __exports as t } from "../../../../../../../../../../../_virtual/_assert2.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/@confio/ics23/node_modules/@noble/hashes/_md.mjs

@@ -0,0 +1,72 @@
+import { __exports as u } from "../../../../../../../../../../../_virtual/_md2.mjs";
+import "./_assert.mjs";
+import "./utils.mjs";
+import { __exports as g } from "../../../../../../../../../../../_virtual/_assert2.mjs";
+import { __exports as _ } from "../../../../../../../../../../../_virtual/utils8.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/@confio/ics23/node_modules/@noble/hashes/_u64.mjs

@@ -0,0 +1,85 @@
+import { __exports as r } from "../../../../../../../../../../../_virtual/_u642.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/@confio/ics23/node_modules/@noble/hashes/crypto.mjs

@@ -0,0 +1,7 @@
+import { __exports as o } from "../../../../../../../../../../../_virtual/crypto2.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
+};