@coinbase/cdp-hooks 0.0.52 → 0.0.53

package/dist/esm/index271.js

@@ -1,80 +1,142 @@
-import { fromString as d } from "./index274.js";
-import { checksum as o } from "./index277.js";
-import { BaseError as c } from "./index266.js";
-import { keccak256 as f } from "./index269.js";
-const l = /^0x[a-fA-F0-9]{40}$/;
-function u(r, t = {}) {
-  const { strict: s = !0 } = t;
-  if (!l.test(r))
-    throw new i({
-      address: r,
-      cause: new h()
-    });
-  if (s) {
-    if (r.toLowerCase() === r)
-      return;
-    if (m(r) !== r)
-      throw new i({
-        address: r,
-        cause: new p()
-      });
-  }
+import { hexToBytes as p, isBytes as B, abytes as v, bytesToHex as d, concatBytes as U } from "./index251.js";
+import { anumber as W, randomBytes as C, utf8ToBytes as G } from "./index251.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const y = /* @__PURE__ */ BigInt(0), g = /* @__PURE__ */ BigInt(1);
+function k(t, r) {
+  if (typeof r != "boolean")
+    throw new Error(t + " boolean expected, got " + r);
 }
-function m(r) {
-  if (o.has(r))
-    return o.get(r);
-  u(r, { strict: !1 });
-  const t = r.substring(2).toLowerCase(), s = f(d(t), { as: "Bytes" }), n = t.split("");
-  for (let e = 0; e < 40; e += 2)
-    s[e >> 1] >> 4 >= 8 && n[e] && (n[e] = n[e].toUpperCase()), (s[e >> 1] & 15) >= 8 && n[e + 1] && (n[e + 1] = n[e + 1].toUpperCase());
-  const a = `0x${n.join("")}`;
-  return o.set(r, a), a;
+function j(t) {
+  const r = t.toString(16);
+  return r.length & 1 ? "0" + r : r;
 }
-function k(r, t = {}) {
-  const { strict: s = !0 } = t ?? {};
-  try {
-    return u(r, { strict: s }), !0;
-  } catch {
-    return !1;
-  }
+function h(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return t === "" ? y : BigInt("0x" + t);
 }
-class i extends c {
-  constructor({ address: t, cause: s }) {
-    super(`Address "${t}" is invalid.`, {
-      cause: s
-    }), Object.defineProperty(this, "name", {
-      enumerable: !0,
-      configurable: !0,
-      writable: !0,
-      value: "Address.InvalidAddressError"
-    });
-  }
+function H(t) {
+  return h(d(t));
 }
-class h extends c {
-  constructor() {
-    super("Address is not a 20 byte (40 hexadecimal character) value."), Object.defineProperty(this, "name", {
-      enumerable: !0,
-      configurable: !0,
-      writable: !0,
-      value: "Address.InvalidInputError"
-    });
-  }
+function O(t) {
+  return v(t), h(d(Uint8Array.from(t).reverse()));
+}
+function x(t, r) {
+  return p(t.toString(16).padStart(r * 2, "0"));
+}
+function S(t, r) {
+  return x(t, r).reverse();
 }
-class p extends c {
-  constructor() {
-    super("Address does not match its checksum counterpart."), Object.defineProperty(this, "name", {
-      enumerable: !0,
-      configurable: !0,
-      writable: !0,
-      value: "Address.InvalidChecksumError"
-    });
+function _(t, r, n) {
+  let o;
+  if (typeof r == "string")
+    try {
+      o = p(r);
+    } catch (e) {
+      throw new Error(t + " must be hex string or Uint8Array, cause: " + e);
+    }
+  else if (B(r))
+    o = Uint8Array.from(r);
+  else
+    throw new Error(t + " must be hex string or Uint8Array");
+  const i = o.length;
+  if (typeof n == "number" && i !== n)
+    throw new Error(t + " of length " + n + " expected, got " + i);
+  return o;
+}
+const w = (t) => typeof t == "bigint" && y <= t;
+function T(t, r, n) {
+  return w(t) && w(r) && w(n) && r <= t && t < n;
+}
+function $(t, r, n, o) {
+  if (!T(r, n, o))
+    throw new Error("expected valid " + t + ": " + n + " <= n < " + o + ", got " + r);
+}
+function M(t) {
+  let r;
+  for (r = 0; t > y; t >>= g, r += 1)
+    ;
+  return r;
+}
+const N = (t) => (g << BigInt(t)) - g;
+function R(t, r, n) {
+  if (typeof t != "number" || t < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof r != "number" || r < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof n != "function")
+    throw new Error("hmacFn must be a function");
+  const o = (u) => new Uint8Array(u), i = (u) => Uint8Array.of(u);
+  let e = o(t), s = o(t), f = 0;
+  const c = () => {
+    e.fill(1), s.fill(0), f = 0;
+  }, l = (...u) => n(s, e, ...u), m = (u = o(0)) => {
+    s = l(i(0), u), e = l(), u.length !== 0 && (s = l(i(1), u), e = l());
+  }, E = () => {
+    if (f++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let u = 0;
+    const a = [];
+    for (; u < r; ) {
+      e = l();
+      const b = e.slice();
+      a.push(b), u += e.length;
+    }
+    return U(...a);
+  };
+  return (u, a) => {
+    c(), m(u);
+    let b;
+    for (; !(b = a(E())); )
+      m();
+    return c(), b;
+  };
+}
+function z(t, r, n = {}) {
+  if (!t || typeof t != "object")
+    throw new Error("expected valid options object");
+  function o(i, e, s) {
+    const f = t[i];
+    if (s && f === void 0)
+      return;
+    const c = typeof f;
+    if (c !== e || f === null)
+      throw new Error(`param "${i}" is invalid: expected ${e}, got ${c}`);
   }
+  Object.entries(r).forEach(([i, e]) => o(i, e, !1)), Object.entries(n).forEach(([i, e]) => o(i, e, !0));
+}
+function D(t) {
+  const r = /* @__PURE__ */ new WeakMap();
+  return (n, ...o) => {
+    const i = r.get(n);
+    if (i !== void 0)
+      return i;
+    const e = t(n, ...o);
+    return r.set(n, e), e;
+  };
 }
 export {
-  i as InvalidAddressError,
-  p as InvalidChecksumError,
-  h as InvalidInputError,
-  u as assert,
-  m as checksum,
-  k as validate
+  z as _validateObject,
+  $ as aInRange,
+  k as abool,
+  v as abytes,
+  W as anumber,
+  M as bitLen,
+  N as bitMask,
+  d as bytesToHex,
+  H as bytesToNumberBE,
+  O as bytesToNumberLE,
+  U as concatBytes,
+  R as createHmacDrbg,
+  _ as ensureBytes,
+  p as hexToBytes,
+  h as hexToNumber,
+  T as inRange,
+  B as isBytes,
+  D as memoized,
+  x as numberToBytesBE,
+  S as numberToBytesLE,
+  j as numberToHexUnpadded,
+  C as randomBytes,
+  G as utf8ToBytes
 };

package/dist/esm/index272.js

@@ -1,6 +1,45 @@
-const e = /^(.*)\[([0-9]*)\]$/, t = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/, n = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+import { Hash as d, ahash as u, toBytes as H, clean as l, aexists as a, abytes as p } from "./index251.js";
+class r extends d {
+  constructor(t, i) {
+    super(), this.finished = !1, this.destroyed = !1, u(t);
+    const h = H(i);
+    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 o = this.blockLen, e = new Uint8Array(o);
+    e.set(h.length > o ? t.create().update(h).digest() : h);
+    for (let s = 0; s < e.length; s++)
+      e[s] ^= 54;
+    this.iHash.update(e), this.oHash = t.create();
+    for (let s = 0; s < e.length; s++)
+      e[s] ^= 106;
+    this.oHash.update(e), l(e);
+  }
+  update(t) {
+    return a(this), this.iHash.update(t), this;
+  }
+  digestInto(t) {
+    a(this), p(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: i, iHash: h, finished: o, destroyed: e, blockLen: s, outputLen: c } = this;
+    return t = t, t.finished = o, t.destroyed = e, t.blockLen = s, t.outputLen = c, t.oHash = i._cloneInto(t.oHash), t.iHash = h._cloneInto(t.iHash), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const y = (n, t, i) => new r(n, t).update(i).digest();
+y.create = (n, t) => new r(n, t);
 export {
-  e as arrayRegex,
-  t as bytesRegex,
-  n as integerRegex
+  r as HMAC,
+  y as hmac
 };

package/dist/esm/index273.js

@@ -1,197 +1,204 @@
-import { InvalidTypeError as g, InvalidArrayError as b, ArrayLengthMismatchError as w, BytesSizeMismatchError as z } from "./index259.js";
-import { assert as x } from "./index271.js";
-import { BaseError as S } from "./index266.js";
-import { size as d, fromNumber as f, concat as p, padLeft as h, fromBoolean as A, IntegerOutOfRangeError as E, padRight as y, fromString as I, slice as B } from "./index255.js";
-import { integerRegex as L } from "./index272.js";
-function q({ checksumAddress: e, parameters: n, values: r }) {
-  const t = [];
-  for (let o = 0; o < n.length; o++)
-    t.push(u({
-      checksumAddress: e,
-      parameter: n[o],
-      value: r[o]
-    }));
-  return t;
+import { bitLen as B, bitMask as z } from "./index271.js";
+import { validateField as Z, Field as O, FpInvertBatch as R } from "./index246.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const g = BigInt(0), h = BigInt(1);
+function b(t, r) {
+  const e = r.negate();
+  return t ? e : r;
 }
-function u({ checksumAddress: e = !1, parameter: n, value: r }) {
-  const t = n, o = k(t.type);
-  if (o) {
-    const [i, c] = o;
-    return P(r, {
-      checksumAddress: e,
-      length: i,
-      parameter: {
-        ...t,
-        type: c
-      }
-    });
-  }
-  if (t.type === "tuple")
-    return R(r, {
-      checksumAddress: e,
-      parameter: t
-    });
-  if (t.type === "address")
-    return N(r, {
-      checksum: e
-    });
-  if (t.type === "bool")
-    return C(r);
-  if (t.type.startsWith("uint") || t.type.startsWith("int")) {
-    const i = t.type.startsWith("int"), [, , c = "256"] = L.exec(t.type) ?? [];
-    return M(r, {
-      signed: i,
-      size: Number(c)
-    });
-  }
-  if (t.type.startsWith("bytes"))
-    return $(r, { type: t.type });
-  if (t.type === "string")
-    return W(r);
-  throw new g(t.type);
+function L(t, r, e) {
+  const n = (s) => s.pz, i = R(t.Fp, e.map(n));
+  return e.map((s, f) => s.toAffine(i[f])).map(t.fromAffine);
 }
-function l(e) {
-  let n = 0;
-  for (let i = 0; i < e.length; i++) {
-    const { dynamic: c, encoded: s } = e[i];
-    c ? n += 32 : n += d(s);
-  }
-  const r = [], t = [];
-  let o = 0;
-  for (let i = 0; i < e.length; i++) {
-    const { dynamic: c, encoded: s } = e[i];
-    c ? (r.push(f(n + o, { size: 32 })), t.push(s), o += d(s)) : r.push(s);
-  }
-  return p(...r, ...t);
+function I(t, r) {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > r)
+    throw new Error("invalid window size, expected [1.." + r + "], got W=" + t);
 }
-function N(e, n) {
-  const { checksum: r = !1 } = n;
-  return x(e, { strict: r }), {
-    dynamic: !1,
-    encoded: h(e.toLowerCase())
-  };
+function E(t, r) {
+  I(t, r);
+  const e = Math.ceil(r / t) + 1, n = 2 ** (t - 1), i = 2 ** t, o = z(t), s = BigInt(t);
+  return { windows: e, windowSize: n, mask: o, maxNumber: i, shiftBy: s };
 }
-function P(e, n) {
-  const { checksumAddress: r, length: t, parameter: o } = n, i = t === null;
-  if (!Array.isArray(e))
-    throw new b(e);
-  if (!i && e.length !== t)
-    throw new w({
-      expectedLength: t,
-      givenLength: e.length,
-      type: `${o.type}[${t}]`
-    });
-  let c = !1;
-  const s = [];
-  for (let a = 0; a < e.length; a++) {
-    const m = u({
-      checksumAddress: r,
-      parameter: o,
-      value: e[a]
-    });
-    m.dynamic && (c = !0), s.push(m);
-  }
-  if (i || c) {
-    const a = l(s);
-    if (i) {
-      const m = f(s.length, { size: 32 });
-      return {
-        dynamic: !0,
-        encoded: s.length > 0 ? p(m, a) : m
-      };
-    }
-    if (c)
-      return { dynamic: !0, encoded: a };
-  }
-  return {
-    dynamic: !1,
-    encoded: p(...s.map(({ encoded: a }) => a))
-  };
+function v(t, r, e) {
+  const { windowSize: n, mask: i, maxNumber: o, shiftBy: s } = e;
+  let f = Number(t & i), a = t >> s;
+  f > n && (f -= o, a += h);
+  const d = r * n, c = d + Math.abs(f) - 1, p = f === 0, l = f < 0, u = r % 2 !== 0;
+  return { nextN: a, offset: c, isZero: p, isNeg: l, isNegF: u, offsetF: d };
 }
-function $(e, { type: n }) {
-  const [, r] = n.split("bytes"), t = d(e);
-  if (!r) {
-    let o = e;
-    return t % 32 !== 0 && (o = y(o, Math.ceil((e.length - 2) / 2 / 32) * 32)), {
-      dynamic: !0,
-      encoded: p(h(f(t, { size: 32 })), o)
-    };
-  }
-  if (t !== Number.parseInt(r))
-    throw new z({
-      expectedSize: Number.parseInt(r),
-      value: e
-    });
-  return { dynamic: !1, encoded: y(e) };
+function j(t, r) {
+  if (!Array.isArray(t))
+    throw new Error("array expected");
+  t.forEach((e, n) => {
+    if (!(e instanceof r))
+      throw new Error("invalid point at index " + n);
+  });
 }
-function C(e) {
-  if (typeof e != "boolean")
-    throw new S(`Invalid boolean value: "${e}" (type: ${typeof e}). Expected: \`true\` or \`false\`.`);
-  return { dynamic: !1, encoded: h(A(e)) };
+function _(t, r) {
+  if (!Array.isArray(t))
+    throw new Error("array of scalars expected");
+  t.forEach((e, n) => {
+    if (!r.isValid(e))
+      throw new Error("invalid scalar at index " + n);
+  });
 }
-function M(e, { signed: n, size: r }) {
-  if (typeof r == "number") {
-    const t = 2n ** (BigInt(r) - (n ? 1n : 0n)) - 1n, o = n ? -t - 1n : 0n;
-    if (e > t || e < o)
-      throw new E({
-        max: t.toString(),
-        min: o.toString(),
-        signed: n,
-        size: r / 8,
-        value: e.toString()
-      });
-  }
-  return {
-    dynamic: !1,
-    encoded: f(e, {
-      size: 32,
-      signed: n
-    })
-  };
+const N = /* @__PURE__ */ new WeakMap(), M = /* @__PURE__ */ new WeakMap();
+function A(t) {
+  return M.get(t) || 1;
 }
-function W(e) {
-  const n = I(e), r = Math.ceil(d(n) / 32), t = [];
-  for (let o = 0; o < r; o++)
-    t.push(y(B(n, o * 32, (o + 1) * 32)));
+function S(t) {
+  if (t !== g)
+    throw new Error("invalid wNAF");
+}
+function U(t, r) {
   return {
-    dynamic: !0,
-    encoded: p(y(f(d(n), { size: 32 })), ...t)
+    constTimeNegate: b,
+    hasPrecomputes(e) {
+      return A(e) !== 1;
+    },
+    // non-const time multiplication ladder
+    unsafeLadder(e, n, i = t.ZERO) {
+      let o = e;
+      for (; n > g; )
+        n & h && (i = i.add(o)), o = o.double(), n >>= h;
+      return i;
+    },
+    /**
+     * Creates a wNAF precomputation window. Used for caching.
+     * Default window size is set by `utils.precompute()` and is equal to 8.
+     * Number of precomputed points depends on the curve size:
+     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+     * - 𝑊 is the window size
+     * - 𝑛 is the bitlength of the curve order.
+     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+     * @param elm Point instance
+     * @param W window size
+     * @returns precomputed point tables flattened to a single array
+     */
+    precomputeWindow(e, n) {
+      const { windows: i, windowSize: o } = E(n, r), s = [];
+      let f = e, a = f;
+      for (let d = 0; d < i; d++) {
+        a = f, s.push(a);
+        for (let c = 1; c < o; c++)
+          a = a.add(f), s.push(a);
+        f = a.double();
+      }
+      return s;
+    },
+    /**
+     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @returns real and fake (for const-time) points
+     */
+    wNAF(e, n, i) {
+      let o = t.ZERO, s = t.BASE;
+      const f = E(e, r);
+      for (let a = 0; a < f.windows; a++) {
+        const { nextN: d, offset: c, isZero: p, isNeg: l, isNegF: u, offsetF: m } = v(i, a, f);
+        i = d, p ? s = s.add(b(u, n[m])) : o = o.add(b(l, n[c]));
+      }
+      return S(i), { p: o, f: s };
+    },
+    /**
+     * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @param acc accumulator point to add result of multiplication
+     * @returns point
+     */
+    wNAFUnsafe(e, n, i, o = t.ZERO) {
+      const s = E(e, r);
+      for (let f = 0; f < s.windows && i !== g; f++) {
+        const { nextN: a, offset: d, isZero: c, isNeg: p } = v(i, f, s);
+        if (i = a, !c) {
+          const l = n[d];
+          o = o.add(p ? l.negate() : l);
+        }
+      }
+      return S(i), o;
+    },
+    getPrecomputes(e, n, i) {
+      let o = N.get(n);
+      return o || (o = this.precomputeWindow(n, e), e !== 1 && (typeof i == "function" && (o = i(o)), N.set(n, o))), o;
+    },
+    wNAFCached(e, n, i) {
+      const o = A(e);
+      return this.wNAF(o, this.getPrecomputes(o, e, i), n);
+    },
+    wNAFCachedUnsafe(e, n, i, o) {
+      const s = A(e);
+      return s === 1 ? this.unsafeLadder(e, n, o) : this.wNAFUnsafe(s, this.getPrecomputes(s, e, i), n, o);
+    },
+    // We calculate precomputes for elliptic curve point multiplication
+    // using windowed method. This specifies window size and
+    // stores precomputed values. Usually only base point would be precomputed.
+    setWindowSize(e, n) {
+      I(n, r), M.set(e, n), N.delete(e);
+    }
   };
 }
-function R(e, n) {
-  const { checksumAddress: r, parameter: t } = n;
-  let o = !1;
-  const i = [];
-  for (let c = 0; c < t.components.length; c++) {
-    const s = t.components[c], a = Array.isArray(e) ? c : s.name, m = u({
-      checksumAddress: r,
-      parameter: s,
-      value: e[a]
-    });
-    i.push(m), m.dynamic && (o = !0);
+function $(t, r, e, n) {
+  let i = r, o = t.ZERO, s = t.ZERO;
+  for (; e > g || n > g; )
+    e & h && (o = o.add(i)), n & h && (s = s.add(i)), i = i.double(), e >>= h, n >>= h;
+  return { p1: o, p2: s };
+}
+function D(t, r, e, n) {
+  j(e, t), _(n, r);
+  const i = e.length, o = n.length;
+  if (i !== o)
+    throw new Error("arrays of points and scalars must have equal length");
+  const s = t.ZERO, f = B(BigInt(i));
+  let a = 1;
+  f > 12 ? a = f - 3 : f > 4 ? a = f - 2 : f > 0 && (a = 2);
+  const d = z(a), c = new Array(Number(d) + 1).fill(s), p = Math.floor((r.BITS - 1) / a) * a;
+  let l = s;
+  for (let u = p; u >= 0; u -= a) {
+    c.fill(s);
+    for (let w = 0; w < o; w++) {
+      const F = n[w], y = Number(F >> BigInt(u) & d);
+      c[y] = c[y].add(e[w]);
+    }
+    let m = s;
+    for (let w = c.length - 1, F = s; w > 0; w--)
+      F = F.add(c[w]), m = m.add(F);
+    if (l = l.add(m), u !== 0)
+      for (let w = 0; w < a; w++)
+        l = l.double();
   }
-  return {
-    dynamic: o,
-    encoded: o ? l(i) : p(...i.map(({ encoded: c }) => c))
-  };
+  return l;
+}
+function x(t, r) {
+  if (r) {
+    if (r.ORDER !== t)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return Z(r), r;
+  } else
+    return O(t);
 }
-function k(e) {
-  const n = e.match(/^(.*)\[(\d+)?\]$/);
-  return n ? (
-    // Return `null` if the array is dynamic.
-    [n[2] ? Number(n[2]) : null, n[1]]
-  ) : void 0;
+function G(t, r, e = {}) {
+  if (!r || typeof r != "object")
+    throw new Error(`expected valid ${t} CURVE object`);
+  for (const f of ["p", "n", "h"]) {
+    const a = r[f];
+    if (!(typeof a == "bigint" && a > g))
+      throw new Error(`CURVE.${f} must be positive bigint`);
+  }
+  const n = x(r.p, e.Fp), i = x(r.n, e.Fn), s = ["Gx", "Gy", "a", "b"];
+  for (const f of s)
+    if (!n.isValid(r[f]))
+      throw new Error(`CURVE.${f} must be valid field element of CURVE.Fp`);
+  return { Fp: n, Fn: i };
 }
 export {
-  l as encode,
-  N as encodeAddress,
-  P as encodeArray,
-  C as encodeBoolean,
-  $ as encodeBytes,
-  M as encodeNumber,
-  W as encodeString,
-  R as encodeTuple,
-  k as getArrayComponents,
-  u as prepareParameter,
-  q as prepareParameters
+  G as _createCurveFields,
+  $ as mulEndoUnsafe,
+  b as negateCt,
+  L as normalizeZ,
+  D as pippenger,
+  U as wNAF
 };