@springmicro/auth 0.7.2 → 0.7.4

package/dist/sha256-JJGtJ2gn.js

@@ -0,0 +1,325 @@
+function m(t) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new Error(`Wrong positive integer: ${t}`);
+}
+function T(t, ...e) {
+  if (!(t instanceof Uint8Array))
+    throw new Error("Expected Uint8Array");
+  if (e.length > 0 && !e.includes(t.length))
+    throw new Error(`Expected Uint8Array of length ${e}, not of length=${t.length}`);
+}
+function Z(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash should be wrapped by utils.wrapConstructor");
+  m(t.outputLen), m(t.blockLen);
+}
+function B(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function I(t, e) {
+  T(t);
+  const s = e.outputLen;
+  if (t.length < s)
+    throw new Error(`digestInto() expects output buffer of length at least ${s}`);
+}
+const A = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const E = (t) => t instanceof Uint8Array, j = (t) => new Uint8Array(t.buffer, t.byteOffset, t.byteLength), C = (t) => new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4)), w = (t) => new DataView(t.buffer, t.byteOffset, t.byteLength), u = (t, e) => t << 32 - e | t >>> e, _ = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+if (!_)
+  throw new Error("Non little-endian hardware is not supported");
+const D = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function N(t) {
+  if (!E(t))
+    throw new Error("Uint8Array expected");
+  let e = "";
+  for (let s = 0; s < t.length; s++)
+    e += D[t[s]];
+  return e;
+}
+function F(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  const e = t.length;
+  if (e % 2)
+    throw new Error("padded hex string expected, got unpadded hex of length " + e);
+  const s = new Uint8Array(e / 2);
+  for (let n = 0; n < s.length; n++) {
+    const o = n * 2, i = t.slice(o, o + 2), r = Number.parseInt(i, 16);
+    if (Number.isNaN(r) || r < 0)
+      throw new Error("Invalid byte sequence");
+    s[n] = r;
+  }
+  return s;
+}
+const H = async () => {
+};
+async function V(t, e, s) {
+  let n = Date.now();
+  for (let o = 0; o < t; o++) {
+    s(o);
+    const i = Date.now() - n;
+    i >= 0 && i < e || (await H(), n += i);
+  }
+}
+function O(t) {
+  if (typeof t != "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof t}`);
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function g(t) {
+  if (typeof t == "string" && (t = O(t)), !E(t))
+    throw new Error(`expected Uint8Array, got ${typeof t}`);
+  return t;
+}
+function $(...t) {
+  const e = new Uint8Array(t.reduce((n, o) => n + o.length, 0));
+  let s = 0;
+  return t.forEach((n) => {
+    if (!E(n))
+      throw new Error("Uint8Array expected");
+    e.set(n, s), s += n.length;
+  }), e;
+}
+class S {
+  // Safe version that clones internal state
+  clone() {
+    return this._cloneInto();
+  }
+}
+const G = {}.toString;
+function W(t, e) {
+  if (e !== void 0 && G.call(e) !== "[object Object]")
+    throw new Error("Options should be object or undefined");
+  return Object.assign(t, e);
+}
+function L(t) {
+  const e = (n) => t().update(g(n)).digest(), s = t();
+  return e.outputLen = s.outputLen, e.blockLen = s.blockLen, e.create = () => t(), e;
+}
+function M(t) {
+  const e = (n, o) => t(o).update(g(n)).digest(), s = t({});
+  return e.outputLen = s.outputLen, e.blockLen = s.blockLen, e.create = (n) => t(n), e;
+}
+function v(t) {
+  const e = (n, o) => t(o).update(g(n)).digest(), s = t({});
+  return e.outputLen = s.outputLen, e.blockLen = s.blockLen, e.create = (n) => t(n), e;
+}
+function R(t = 32) {
+  if (A && typeof A.getRandomValues == "function")
+    return A.getRandomValues(new Uint8Array(t));
+  throw new Error("crypto.getRandomValues must be defined");
+}
+const tt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Hash: S,
+  asyncLoop: V,
+  bytesToHex: N,
+  checkOpts: W,
+  concatBytes: $,
+  createView: w,
+  hexToBytes: F,
+  isLE: _,
+  nextTick: H,
+  randomBytes: R,
+  rotr: u,
+  toBytes: g,
+  u32: C,
+  u8: j,
+  utf8ToBytes: O,
+  wrapConstructor: L,
+  wrapConstructorWithOpts: M,
+  wrapXOFConstructorWithOpts: v
+}, Symbol.toStringTag, { value: "Module" }));
+function z(t, e, s, n) {
+  if (typeof t.setBigUint64 == "function")
+    return t.setBigUint64(e, s, n);
+  const o = BigInt(32), i = BigInt(4294967295), r = Number(s >> o & i), f = Number(s & i), h = n ? 4 : 0, a = n ? 0 : 4;
+  t.setUint32(e + h, r, n), t.setUint32(e + a, f, n);
+}
+class P extends S {
+  constructor(e, s, n, o) {
+    super(), this.blockLen = e, this.outputLen = s, this.padOffset = n, this.isLE = o, this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.buffer = new Uint8Array(e), this.view = w(this.buffer);
+  }
+  update(e) {
+    B(this);
+    const { view: s, buffer: n, blockLen: o } = this;
+    e = g(e);
+    const i = e.length;
+    for (let r = 0; r < i; ) {
+      const f = Math.min(o - this.pos, i - r);
+      if (f === o) {
+        const h = w(e);
+        for (; o <= i - r; r += o)
+          this.process(h, r);
+        continue;
+      }
+      n.set(e.subarray(r, r + f), this.pos), this.pos += f, r += f, this.pos === o && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    B(this), I(e, this), this.finished = !0;
+    const { buffer: s, view: n, blockLen: o, isLE: i } = this;
+    let { pos: r } = this;
+    s[r++] = 128, this.buffer.subarray(r).fill(0), this.padOffset > o - r && (this.process(n, 0), r = 0);
+    for (let c = r; c < o; c++)
+      s[c] = 0;
+    z(n, o - 8, BigInt(this.length * 8), i), this.process(n, 0);
+    const f = w(e), h = this.outputLen;
+    if (h % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const a = h / 4, x = this.get();
+    if (a > x.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let c = 0; c < a; c++)
+      f.setUint32(4 * c, x[c], i);
+  }
+  digest() {
+    const { buffer: e, outputLen: s } = this;
+    this.digestInto(e);
+    const n = e.slice(0, s);
+    return this.destroy(), n;
+  }
+  _cloneInto(e) {
+    e || (e = new this.constructor()), e.set(...this.get());
+    const { blockLen: s, buffer: n, length: o, finished: i, destroyed: r, pos: f } = this;
+    return e.length = o, e.pos = f, e.finished = i, e.destroyed = r, o % s && e.buffer.set(n), e;
+  }
+}
+const q = (t, e, s) => t & e ^ ~t & s, K = (t, e, s) => t & e ^ t & s ^ e & s, X = /* @__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
+]), l = /* @__PURE__ */ new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), d = /* @__PURE__ */ new Uint32Array(64);
+class k extends P {
+  constructor() {
+    super(64, 32, 8, !1), this.A = l[0] | 0, this.B = l[1] | 0, this.C = l[2] | 0, this.D = l[3] | 0, this.E = l[4] | 0, this.F = l[5] | 0, this.G = l[6] | 0, this.H = l[7] | 0;
+  }
+  get() {
+    const { A: e, B: s, C: n, D: o, E: i, F: r, G: f, H: h } = this;
+    return [e, s, n, o, i, r, f, h];
+  }
+  // prettier-ignore
+  set(e, s, n, o, i, r, f, h) {
+    this.A = e | 0, this.B = s | 0, this.C = n | 0, this.D = o | 0, this.E = i | 0, this.F = r | 0, this.G = f | 0, this.H = h | 0;
+  }
+  process(e, s) {
+    for (let c = 0; c < 16; c++, s += 4)
+      d[c] = e.getUint32(s, !1);
+    for (let c = 16; c < 64; c++) {
+      const p = d[c - 15], b = d[c - 2], U = u(p, 7) ^ u(p, 18) ^ p >>> 3, y = u(b, 17) ^ u(b, 19) ^ b >>> 10;
+      d[c] = y + d[c - 7] + U + d[c - 16] | 0;
+    }
+    let { A: n, B: o, C: i, D: r, E: f, F: h, G: a, H: x } = this;
+    for (let c = 0; c < 64; c++) {
+      const p = u(f, 6) ^ u(f, 11) ^ u(f, 25), b = x + p + q(f, h, a) + X[c] + d[c] | 0, y = (u(n, 2) ^ u(n, 13) ^ u(n, 22)) + K(n, o, i) | 0;
+      x = a, a = h, h = f, f = r + b | 0, r = i, i = o, o = n, n = b + y | 0;
+    }
+    n = n + this.A | 0, o = o + this.B | 0, i = i + this.C | 0, r = r + this.D | 0, f = f + this.E | 0, h = h + this.F | 0, a = a + this.G | 0, x = x + this.H | 0, this.set(n, o, i, r, f, h, a, x);
+  }
+  roundClean() {
+    d.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), this.buffer.fill(0);
+  }
+}
+class J extends k {
+  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;
+  }
+}
+const Q = /* @__PURE__ */ L(() => new k()), Y = /* @__PURE__ */ L(() => new J()), et = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  sha224: Y,
+  sha256: Q
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  S as H,
+  et as a,
+  T as b,
+  $ as c,
+  C as d,
+  B as e,
+  Z as h,
+  m as n,
+  I as o,
+  R as r,
+  Q as s,
+  g as t,
+  tt as u,
+  L as w
+};

package/dist/{transactionRequest-be6a8ea9-CUKWo5mx.js → transactionRequest-be6a8ea9-_q5BIZxq.js}

@@ -1053,57 +1053,57 @@ function Tt(e) {
   return typeof e.accessList < "u" && (t.accessList = e.accessList), typeof e.blobVersionedHashes < "u" && (t.blobVersionedHashes = e.blobVersionedHashes), typeof e.blobs < "u" && (typeof e.blobs[0] != "string" ? t.blobs = e.blobs.map((r) => E(r)) : t.blobs = e.blobs), typeof e.data < "u" && (t.data = e.data), typeof e.from < "u" && (t.from = e.from), typeof e.gas < "u" && (t.gas = l(e.gas)), typeof e.gasPrice < "u" && (t.gasPrice = l(e.gasPrice)), typeof e.maxFeePerBlobGas < "u" && (t.maxFeePerBlobGas = l(e.maxFeePerBlobGas)), typeof e.maxFeePerGas < "u" && (t.maxFeePerGas = l(e.maxFeePerGas)), typeof e.maxPriorityFeePerGas < "u" && (t.maxPriorityFeePerGas = l(e.maxPriorityFeePerGas)), typeof e.nonce < "u" && (t.nonce = l(e.nonce)), typeof e.to < "u" && (t.to = e.to), typeof e.type < "u" && (t.type = nt[e.type]), typeof e.value < "u" && (t.value = l(e.value)), t;
 }
 export {
-  Je as $,
-  q as A,
+  tt as $,
+  Tt as A,
   a as B,
-  ne as C,
-  se as D,
-  st as E,
+  $t as C,
+  vt as D,
+  M as E,
   De as F,
-  Tt as G,
+  Se as G,
   ve as H,
   lt as I,
-  $t as J,
-  vt as K,
-  ze as L,
-  tt as M,
-  Se as N,
-  M as O,
-  yt as P,
-  g as Q,
-  ot as R,
-  _e as S,
+  pt as J,
+  yt as K,
+  _ as L,
+  Xe as M,
+  We as N,
+  Ke as O,
+  Ye as P,
+  Je as Q,
+  Qe as R,
+  Ze as S,
   et as T,
   Ot as U,
-  x as V,
-  _ as W,
-  Xe as X,
-  We as Y,
-  Ke as Z,
-  Ye as _,
+  qe as V,
+  _e as W,
+  x as X,
+  ut as Y,
+  Ge as Z,
+  ze as _,
   ct as a,
-  Qe as a0,
-  Ze as a1,
-  qe as a2,
-  Ge as a3,
-  ut as a4,
-  mt as a5,
-  it as a6,
+  q as a0,
+  ne as a1,
+  se as a2,
+  it as a3,
+  g as a4,
+  ot as a5,
+  mt as a6,
   gt as b,
   Re as c,
   ft as d,
   E as e,
-  k as f,
+  xt as f,
   wt as g,
   fe as h,
   bt as i,
-  at as j,
-  It as k,
-  Et as l,
-  xt as m,
-  Pt as n,
-  P as o,
-  ae as p,
+  Et as j,
+  Pt as k,
+  at as l,
+  It as m,
+  k as n,
+  ae as o,
+  P as p,
   ht as q,
   L as r,
   b as s,
@@ -1112,6 +1112,6 @@ export {
   le as v,
   $e as w,
   dt as x,
-  l as y,
-  pt as z
+  st as y,
+  l as z
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springmicro/auth",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "private": false,
   "publishConfig": {
     "access": "public",
@@ -53,5 +53,5 @@
     "react-social-login-buttons": "^4.1.0",
     "uuid": "^9.0.1"
   },
-  "gitHead": "baedb0de00a8f238a2356a747e69eb1754606d58"
+  "gitHead": "b786438d6e75f39145e05d4583a7926eda3c4bf3"
 }