@coinbase/cdp-hooks 0.0.95 → 0.0.96

package/dist/esm/index352.js

@@ -0,0 +1,122 @@
+import { BaseError as c } from "./index340.js";
+import { padRight as g, fromBytes as m, toNumber as h, toBigInt as z } from "./index332.js";
+import { charCodeToBase16 as b, assertSize as o, trim as y, pad as p } from "./index357.js";
+import { assertSize as x } from "./index347.js";
+const B = /* @__PURE__ */ new TextDecoder(), $ = /* @__PURE__ */ new TextEncoder();
+function U(e) {
+  return e instanceof Uint8Array ? e : typeof e == "string" ? S(e) : w(e);
+}
+function w(e) {
+  return e instanceof Uint8Array ? e : new Uint8Array(e);
+}
+function S(e, r = {}) {
+  const { size: n } = r;
+  let t = e;
+  n && (x(e, n), t = g(e, n));
+  let i = t.slice(2);
+  i.length % 2 && (i = `0${i}`);
+  const a = i.length / 2, f = new Uint8Array(a);
+  for (let u = 0, s = 0; u < a; u++) {
+    const d = b(i.charCodeAt(s++)), l = b(i.charCodeAt(s++));
+    if (d === void 0 || l === void 0)
+      throw new c(`Invalid byte sequence ("${i[s - 2]}${i[s - 1]}" in "${i}").`);
+    f[u] = d << 4 | l;
+  }
+  return f;
+}
+function j(e, r = {}) {
+  const { size: n } = r, t = $.encode(e);
+  return typeof n == "number" ? (o(t, n), E(t, n)) : t;
+}
+function E(e, r) {
+  return p(e, { dir: "right", size: r });
+}
+function T(e) {
+  return e.length;
+}
+function _(e, r, n, t = {}) {
+  const { strict: i } = t;
+  return e.slice(r, n);
+}
+function L(e, r = {}) {
+  const { size: n } = r;
+  typeof n < "u" && o(e, n);
+  const t = m(e, r);
+  return z(t, r);
+}
+function N(e, r = {}) {
+  const { size: n } = r;
+  let t = e;
+  if (typeof n < "u" && (o(t, n), t = A(t)), t.length > 1 || t[0] > 1)
+    throw new I(t);
+  return !!t[0];
+}
+function q(e, r = {}) {
+  const { size: n } = r;
+  typeof n < "u" && o(e, n);
+  const t = m(e, r);
+  return h(t, r);
+}
+function D(e, r = {}) {
+  const { size: n } = r;
+  let t = e;
+  return typeof n < "u" && (o(t, n), t = v(t)), B.decode(t);
+}
+function A(e) {
+  return y(e, { dir: "left" });
+}
+function v(e) {
+  return y(e, { dir: "right" });
+}
+class I extends c {
+  constructor(r) {
+    super(`Bytes value \`${r}\` is not a valid boolean.`, {
+      metaMessages: [
+        "The bytes array must contain a single byte of either a `0` or `1` value."
+      ]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Bytes.InvalidBytesBooleanError"
+    });
+  }
+}
+class G extends c {
+  constructor({ givenSize: r, maxSize: n }) {
+    super(`Size cannot exceed \`${n}\` bytes. Given size: \`${r}\` bytes.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Bytes.SizeOverflowError"
+    });
+  }
+}
+class H extends c {
+  constructor({ size: r, targetSize: n, type: t }) {
+    super(`${t.charAt(0).toUpperCase()}${t.slice(1).toLowerCase()} size (\`${r}\`) exceeds padding size (\`${n}\`).`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Bytes.SizeExceedsPaddingSizeError"
+    });
+  }
+}
+export {
+  I as InvalidBytesBooleanError,
+  H as SizeExceedsPaddingSizeError,
+  G as SizeOverflowError,
+  U as from,
+  w as fromArray,
+  S as fromHex,
+  j as fromString,
+  E as padRight,
+  T as size,
+  _ as slice,
+  L as toBigInt,
+  N as toBoolean,
+  q as toNumber,
+  D as toString,
+  A as trimLeft,
+  v as trimRight
+};

package/dist/esm/index353.js

@@ -0,0 +1,345 @@
+import { InvalidTypeError as C, InvalidArrayError as _, ArrayLengthMismatchError as $, BytesSizeMismatchError as O } from "./index336.js";
+import { assert as M, checksum as R } from "./index351.js";
+import { toNumber as u, slice as T, toBoolean as D, toBigInt as U, toString as V, trimLeft as j } from "./index352.js";
+import { BaseError as q } from "./index340.js";
+import { size as h, fromNumber as B, concat as m, fromBytes as w, padLeft as S, fromBoolean as F, IntegerOutOfRangeError as G, padRight as b, fromString as H, slice as J } from "./index332.js";
+import { integerRegex as K } from "./index355.js";
+function l(t, e, s) {
+  const { checksumAddress: n, staticPosition: o } = s, i = I(e.type);
+  if (i) {
+    const [r, d] = i;
+    return X(t, { ...e, type: d }, { checksumAddress: n, length: r, staticPosition: o });
+  }
+  if (e.type === "tuple")
+    return tt(t, e, {
+      checksumAddress: n,
+      staticPosition: o
+    });
+  if (e.type === "address")
+    return Q(t, { checksum: n });
+  if (e.type === "bool")
+    return Y(t);
+  if (e.type.startsWith("bytes"))
+    return Z(t, e, { staticPosition: o });
+  if (e.type.startsWith("uint") || e.type.startsWith("int"))
+    return v(t, e);
+  if (e.type === "string")
+    return et(t, { staticPosition: o });
+  throw new C(e.type);
+}
+const k = 32, A = 32;
+function Q(t, e = {}) {
+  const { checksum: s = !1 } = e, n = t.readBytes(32);
+  return [((i) => s ? R(i) : i)(w(T(n, -20))), 32];
+}
+function X(t, e, s) {
+  const { checksumAddress: n, length: o, staticPosition: i } = s;
+  if (!o) {
+    const c = u(t.readBytes(A)), a = i + c, f = a + k;
+    t.setPosition(a);
+    const y = u(t.readBytes(k)), p = g(e);
+    let P = 0;
+    const N = [];
+    for (let z = 0; z < y; ++z) {
+      t.setPosition(f + (p ? z * 32 : P));
+      const [L, E] = l(t, e, {
+        checksumAddress: n,
+        staticPosition: f
+      });
+      P += E, N.push(L);
+    }
+    return t.setPosition(i + 32), [N, 32];
+  }
+  if (g(e)) {
+    const c = u(t.readBytes(A)), a = i + c, f = [];
+    for (let y = 0; y < o; ++y) {
+      t.setPosition(a + y * 32);
+      const [p] = l(t, e, {
+        checksumAddress: n,
+        staticPosition: a
+      });
+      f.push(p);
+    }
+    return t.setPosition(i + 32), [f, 32];
+  }
+  let r = 0;
+  const d = [];
+  for (let c = 0; c < o; ++c) {
+    const [a, f] = l(t, e, {
+      checksumAddress: n,
+      staticPosition: i + r
+    });
+    r += f, d.push(a);
+  }
+  return [d, r];
+}
+function Y(t) {
+  return [D(t.readBytes(32), { size: 32 }), 32];
+}
+function Z(t, e, { staticPosition: s }) {
+  const [n, o] = e.type.split("bytes");
+  if (!o) {
+    const r = u(t.readBytes(32));
+    t.setPosition(s + r);
+    const d = u(t.readBytes(32));
+    if (d === 0)
+      return t.setPosition(s + 32), ["0x", 32];
+    const c = t.readBytes(d);
+    return t.setPosition(s + 32), [w(c), 32];
+  }
+  return [w(t.readBytes(Number.parseInt(o, 10), 32)), 32];
+}
+function v(t, e) {
+  const s = e.type.startsWith("int"), n = Number.parseInt(e.type.split("int")[1] || "256", 10), o = t.readBytes(32);
+  return [
+    n > 48 ? U(o, { signed: s }) : u(o, { signed: s }),
+    32
+  ];
+}
+function tt(t, e, s) {
+  const { checksumAddress: n, staticPosition: o } = s, i = e.components.length === 0 || e.components.some(({ name: c }) => !c), r = i ? [] : {};
+  let d = 0;
+  if (g(e)) {
+    const c = u(t.readBytes(A)), a = o + c;
+    for (let f = 0; f < e.components.length; ++f) {
+      const y = e.components[f];
+      t.setPosition(a + d);
+      const [p, P] = l(t, y, {
+        checksumAddress: n,
+        staticPosition: a
+      });
+      d += P, r[i ? f : y?.name] = p;
+    }
+    return t.setPosition(o + 32), [r, 32];
+  }
+  for (let c = 0; c < e.components.length; ++c) {
+    const a = e.components[c], [f, y] = l(t, a, {
+      checksumAddress: n,
+      staticPosition: o
+    });
+    r[i ? c : a?.name] = f, d += y;
+  }
+  return [r, d];
+}
+function et(t, { staticPosition: e }) {
+  const s = u(t.readBytes(32)), n = e + s;
+  t.setPosition(n);
+  const o = u(t.readBytes(32));
+  if (o === 0)
+    return t.setPosition(e + 32), ["", 32];
+  const i = t.readBytes(o, 32), r = V(j(i));
+  return t.setPosition(e + 32), [r, 32];
+}
+function lt({ checksumAddress: t, parameters: e, values: s }) {
+  const n = [];
+  for (let o = 0; o < e.length; o++)
+    n.push(x({
+      checksumAddress: t,
+      parameter: e[o],
+      value: s[o]
+    }));
+  return n;
+}
+function x({ checksumAddress: t = !1, parameter: e, value: s }) {
+  const n = e, o = I(n.type);
+  if (o) {
+    const [i, r] = o;
+    return ot(s, {
+      checksumAddress: t,
+      length: i,
+      parameter: {
+        ...n,
+        type: r
+      }
+    });
+  }
+  if (n.type === "tuple")
+    return dt(s, {
+      checksumAddress: t,
+      parameter: n
+    });
+  if (n.type === "address")
+    return nt(s, {
+      checksum: t
+    });
+  if (n.type === "bool")
+    return it(s);
+  if (n.type.startsWith("uint") || n.type.startsWith("int")) {
+    const i = n.type.startsWith("int"), [, , r = "256"] = K.exec(n.type) ?? [];
+    return rt(s, {
+      signed: i,
+      size: Number(r)
+    });
+  }
+  if (n.type.startsWith("bytes"))
+    return st(s, { type: n.type });
+  if (n.type === "string")
+    return ct(s);
+  throw new C(n.type);
+}
+function W(t) {
+  let e = 0;
+  for (let i = 0; i < t.length; i++) {
+    const { dynamic: r, encoded: d } = t[i];
+    r ? e += 32 : e += h(d);
+  }
+  const s = [], n = [];
+  let o = 0;
+  for (let i = 0; i < t.length; i++) {
+    const { dynamic: r, encoded: d } = t[i];
+    r ? (s.push(B(e + o, { size: 32 })), n.push(d), o += h(d)) : s.push(d);
+  }
+  return m(...s, ...n);
+}
+function nt(t, e) {
+  const { checksum: s = !1 } = e;
+  return M(t, { strict: s }), {
+    dynamic: !1,
+    encoded: S(t.toLowerCase())
+  };
+}
+function ot(t, e) {
+  const { checksumAddress: s, length: n, parameter: o } = e, i = n === null;
+  if (!Array.isArray(t))
+    throw new _(t);
+  if (!i && t.length !== n)
+    throw new $({
+      expectedLength: n,
+      givenLength: t.length,
+      type: `${o.type}[${n}]`
+    });
+  let r = !1;
+  const d = [];
+  for (let c = 0; c < t.length; c++) {
+    const a = x({
+      checksumAddress: s,
+      parameter: o,
+      value: t[c]
+    });
+    a.dynamic && (r = !0), d.push(a);
+  }
+  if (i || r) {
+    const c = W(d);
+    if (i) {
+      const a = B(d.length, { size: 32 });
+      return {
+        dynamic: !0,
+        encoded: d.length > 0 ? m(a, c) : a
+      };
+    }
+    if (r)
+      return { dynamic: !0, encoded: c };
+  }
+  return {
+    dynamic: !1,
+    encoded: m(...d.map(({ encoded: c }) => c))
+  };
+}
+function st(t, { type: e }) {
+  const [, s] = e.split("bytes"), n = h(t);
+  if (!s) {
+    let o = t;
+    return n % 32 !== 0 && (o = b(o, Math.ceil((t.length - 2) / 2 / 32) * 32)), {
+      dynamic: !0,
+      encoded: m(S(B(n, { size: 32 })), o)
+    };
+  }
+  if (n !== Number.parseInt(s, 10))
+    throw new O({
+      expectedSize: Number.parseInt(s, 10),
+      value: t
+    });
+  return { dynamic: !1, encoded: b(t) };
+}
+function it(t) {
+  if (typeof t != "boolean")
+    throw new q(`Invalid boolean value: "${t}" (type: ${typeof t}). Expected: \`true\` or \`false\`.`);
+  return { dynamic: !1, encoded: S(F(t)) };
+}
+function rt(t, { signed: e, size: s }) {
+  if (typeof s == "number") {
+    const n = 2n ** (BigInt(s) - (e ? 1n : 0n)) - 1n, o = e ? -n - 1n : 0n;
+    if (t > n || t < o)
+      throw new G({
+        max: n.toString(),
+        min: o.toString(),
+        signed: e,
+        size: s / 8,
+        value: t.toString()
+      });
+  }
+  return {
+    dynamic: !1,
+    encoded: B(t, {
+      size: 32,
+      signed: e
+    })
+  };
+}
+function ct(t) {
+  const e = H(t), s = Math.ceil(h(e) / 32), n = [];
+  for (let o = 0; o < s; o++)
+    n.push(b(J(e, o * 32, (o + 1) * 32)));
+  return {
+    dynamic: !0,
+    encoded: m(b(B(h(e), { size: 32 })), ...n)
+  };
+}
+function dt(t, e) {
+  const { checksumAddress: s, parameter: n } = e;
+  let o = !1;
+  const i = [];
+  for (let r = 0; r < n.components.length; r++) {
+    const d = n.components[r], c = Array.isArray(t) ? r : d.name, a = x({
+      checksumAddress: s,
+      parameter: d,
+      value: t[c]
+    });
+    i.push(a), a.dynamic && (o = !0);
+  }
+  return {
+    dynamic: o,
+    encoded: o ? W(i) : m(...i.map(({ encoded: r }) => r))
+  };
+}
+function I(t) {
+  const e = t.match(/^(.*)\[(\d+)?\]$/);
+  return e ? (
+    // Return `null` if the array is dynamic.
+    [e[2] ? Number(e[2]) : null, e[1]]
+  ) : void 0;
+}
+function g(t) {
+  const { type: e } = t;
+  if (e === "string" || e === "bytes" || e.endsWith("[]"))
+    return !0;
+  if (e === "tuple")
+    return t.components?.some(g);
+  const s = I(t.type);
+  return !!(s && g({
+    ...t,
+    type: s[1]
+  }));
+}
+export {
+  Q as decodeAddress,
+  X as decodeArray,
+  Y as decodeBool,
+  Z as decodeBytes,
+  v as decodeNumber,
+  l as decodeParameter,
+  et as decodeString,
+  tt as decodeTuple,
+  W as encode,
+  nt as encodeAddress,
+  ot as encodeArray,
+  it as encodeBoolean,
+  st as encodeBytes,
+  rt as encodeNumber,
+  ct as encodeString,
+  dt as encodeTuple,
+  I as getArrayComponents,
+  g as hasDynamicChild,
+  x as prepareParameter,
+  lt as prepareParameters
+};

package/dist/esm/index354.js

@@ -0,0 +1,163 @@
+import { BaseError as e } from "./index340.js";
+const n = {
+  bytes: new Uint8Array(),
+  dataView: new DataView(new ArrayBuffer(0)),
+  position: 0,
+  positionReadCount: /* @__PURE__ */ new Map(),
+  recursiveReadCount: 0,
+  recursiveReadLimit: Number.POSITIVE_INFINITY,
+  assertReadLimit() {
+    if (this.recursiveReadCount >= this.recursiveReadLimit)
+      throw new h({
+        count: this.recursiveReadCount + 1,
+        limit: this.recursiveReadLimit
+      });
+  },
+  assertPosition(t) {
+    if (t < 0 || t > this.bytes.length - 1)
+      throw new r({
+        length: this.bytes.length,
+        position: t
+      });
+  },
+  decrementPosition(t) {
+    if (t < 0)
+      throw new o({ offset: t });
+    const i = this.position - t;
+    this.assertPosition(i), this.position = i;
+  },
+  getReadCount(t) {
+    return this.positionReadCount.get(t || this.position) || 0;
+  },
+  incrementPosition(t) {
+    if (t < 0)
+      throw new o({ offset: t });
+    const i = this.position + t;
+    this.assertPosition(i), this.position = i;
+  },
+  inspectByte(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i), this.bytes[i];
+  },
+  inspectBytes(t, i) {
+    const s = i ?? this.position;
+    return this.assertPosition(s + t - 1), this.bytes.subarray(s, s + t);
+  },
+  inspectUint8(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i), this.bytes[i];
+  },
+  inspectUint16(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 1), this.dataView.getUint16(i);
+  },
+  inspectUint24(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 2), (this.dataView.getUint16(i) << 8) + this.dataView.getUint8(i + 2);
+  },
+  inspectUint32(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 3), this.dataView.getUint32(i);
+  },
+  pushByte(t) {
+    this.assertPosition(this.position), this.bytes[this.position] = t, this.position++;
+  },
+  pushBytes(t) {
+    this.assertPosition(this.position + t.length - 1), this.bytes.set(t, this.position), this.position += t.length;
+  },
+  pushUint8(t) {
+    this.assertPosition(this.position), this.bytes[this.position] = t, this.position++;
+  },
+  pushUint16(t) {
+    this.assertPosition(this.position + 1), this.dataView.setUint16(this.position, t), this.position += 2;
+  },
+  pushUint24(t) {
+    this.assertPosition(this.position + 2), this.dataView.setUint16(this.position, t >> 8), this.dataView.setUint8(this.position + 2, t & 255), this.position += 3;
+  },
+  pushUint32(t) {
+    this.assertPosition(this.position + 3), this.dataView.setUint32(this.position, t), this.position += 4;
+  },
+  readByte() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectByte();
+    return this.position++, t;
+  },
+  readBytes(t, i) {
+    this.assertReadLimit(), this._touch();
+    const s = this.inspectBytes(t);
+    return this.position += i ?? t, s;
+  },
+  readUint8() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint8();
+    return this.position += 1, t;
+  },
+  readUint16() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint16();
+    return this.position += 2, t;
+  },
+  readUint24() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint24();
+    return this.position += 3, t;
+  },
+  readUint32() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint32();
+    return this.position += 4, t;
+  },
+  get remaining() {
+    return this.bytes.length - this.position;
+  },
+  setPosition(t) {
+    const i = this.position;
+    return this.assertPosition(t), this.position = t, () => this.position = i;
+  },
+  _touch() {
+    if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
+      return;
+    const t = this.getReadCount();
+    this.positionReadCount.set(this.position, t + 1), t > 0 && this.recursiveReadCount++;
+  }
+};
+function u(t, { recursiveReadLimit: i = 8192 } = {}) {
+  const s = Object.create(n);
+  return s.bytes = t, s.dataView = new DataView(t.buffer, t.byteOffset, t.byteLength), s.positionReadCount = /* @__PURE__ */ new Map(), s.recursiveReadLimit = i, s;
+}
+class o extends e {
+  constructor({ offset: i }) {
+    super(`Offset \`${i}\` cannot be negative.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Cursor.NegativeOffsetError"
+    });
+  }
+}
+class r extends e {
+  constructor({ length: i, position: s }) {
+    super(`Position \`${s}\` is out of bounds (\`0 < position < ${i}\`).`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Cursor.PositionOutOfBoundsError"
+    });
+  }
+}
+class h extends e {
+  constructor({ count: i, limit: s }) {
+    super(`Recursive read limit of \`${s}\` exceeded (recursive read count: \`${i}\`).`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Cursor.RecursiveReadLimitExceededError"
+    });
+  }
+}
+export {
+  o as NegativeOffsetError,
+  r as PositionOutOfBoundsError,
+  h as RecursiveReadLimitExceededError,
+  u as create
+};

package/dist/esm/index355.js

@@ -0,0 +1,7 @@
+const e = /^(.*)\[([0-9]*)\]$/, n = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/, t = /^(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)?$/, s = 2n ** 256n - 1n;
+export {
+  e as arrayRegex,
+  n as bytesRegex,
+  t as integerRegex,
+  s as maxUint256
+};

package/dist/esm/index356.js

@@ -0,0 +1,7 @@
+import { version as r } from "./index359.js";
+function e() {
+  return r;
+}
+export {
+  e as getVersion
+};

package/dist/esm/index357.js

@@ -0,0 +1,55 @@
+import { size as d, SizeOverflowError as g, SizeExceedsPaddingSizeError as s } from "./index352.js";
+function z(e, r) {
+  if (d(e) > r)
+    throw new g({
+      givenSize: d(e),
+      maxSize: r
+    });
+}
+const i = {
+  zero: 48,
+  nine: 57,
+  A: 65,
+  F: 70,
+  a: 97,
+  f: 102
+};
+function a(e) {
+  if (e >= i.zero && e <= i.nine)
+    return e - i.zero;
+  if (e >= i.A && e <= i.F)
+    return e - (i.A - 10);
+  if (e >= i.a && e <= i.f)
+    return e - (i.a - 10);
+}
+function S(e, r = {}) {
+  const { dir: f, size: n = 32 } = r;
+  if (n === 0)
+    return e;
+  if (e.length > n)
+    throw new s({
+      size: e.length,
+      targetSize: n,
+      type: "Bytes"
+    });
+  const o = new Uint8Array(n);
+  for (let t = 0; t < n; t++) {
+    const l = f === "right";
+    o[l ? t : n - t - 1] = e[l ? t : e.length - t - 1];
+  }
+  return o;
+}
+function c(e, r = {}) {
+  const { dir: f = "left" } = r;
+  let n = e, o = 0;
+  for (let t = 0; t < n.length - 1 && n[f === "left" ? t : n.length - t - 1].toString() === "0"; t++)
+    o++;
+  return n = f === "left" ? n.slice(o) : n.slice(0, n.length - o), n;
+}
+export {
+  z as assertSize,
+  i as charCodeMap,
+  a as charCodeToBase16,
+  S as pad,
+  c as trim
+};

package/dist/esm/index358.js

@@ -0,0 +1,7 @@
+import { LruMap as c } from "./index360.js";
+const e = {
+  checksum: /* @__PURE__ */ new c(8192)
+}, m = e.checksum;
+export {
+  m as checksum
+};

package/dist/esm/index359.js

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