@coinbase/cdp-hooks 0.0.18 → 0.0.20

package/dist/esm/index197.js

@@ -0,0 +1,68 @@
+import { isTupleRegex as g, execTyped as w } from "./index194.js";
+import { UnknownTypeError as S } from "./index200.js";
+import { InvalidAbiTypeParameterError as d } from "./index201.js";
+import { InvalidSignatureError as T, InvalidStructSignatureError as v } from "./index202.js";
+import { CircularReferenceError as x } from "./index204.js";
+import { isStructSignature as E, execStructSignature as b } from "./index196.js";
+import { parseAbiParameter as A, isSolidityType as $ } from "./index198.js";
+function C(s) {
+  const n = {}, c = s.length;
+  for (let t = 0; t < c; t++) {
+    const i = s[t];
+    if (!E(i))
+      continue;
+    const r = b(i);
+    if (!r)
+      throw new T({ signature: i, type: "struct" });
+    const u = r.properties.split(";"), e = [], h = u.length;
+    for (let l = 0; l < h; l++) {
+      const m = u[l].trim();
+      if (!m)
+        continue;
+      const y = A(m, {
+        type: "struct"
+      });
+      e.push(y);
+    }
+    if (!e.length)
+      throw new v({ signature: i });
+    n[r.name] = e;
+  }
+  const o = {}, a = Object.entries(n), p = a.length;
+  for (let t = 0; t < p; t++) {
+    const [i, r] = a[t];
+    o[i] = f(r, n);
+  }
+  return o;
+}
+const I = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
+function f(s, n, c = /* @__PURE__ */ new Set()) {
+  const o = [], a = s.length;
+  for (let p = 0; p < a; p++) {
+    const t = s[p];
+    if (g.test(t.type))
+      o.push(t);
+    else {
+      const r = w(I, t.type);
+      if (!r?.type)
+        throw new d({ abiParameter: t });
+      const { array: u, type: e } = r;
+      if (e in n) {
+        if (c.has(e))
+          throw new x({ type: e });
+        o.push({
+          ...t,
+          type: `tuple${u ?? ""}`,
+          components: f(n[e] ?? [], n, /* @__PURE__ */ new Set([...c, e]))
+        });
+      } else if ($(e))
+        o.push(t);
+      else
+        throw new S({ type: e });
+    }
+  }
+  return o;
+}
+export {
+  C as parseStructs
+};

package/dist/esm/index198.js

@@ -0,0 +1,188 @@
+import { execTyped as $, bytesRegex as w, integerRegex as S, isTupleRegex as v } from "./index194.js";
+import { UnknownSolidityTypeError as E } from "./index200.js";
+import { InvalidParameterError as P, SolidityProtectedKeywordError as M, InvalidModifierError as R, InvalidFunctionModifierError as k } from "./index201.js";
+import { UnknownSignatureError as z, InvalidSignatureError as p } from "./index202.js";
+import { InvalidParenthesisError as A } from "./index203.js";
+import { getParameterCacheKey as F, parameterCache as y } from "./index242.js";
+import { isFunctionSignature as T, isEventSignature as _, isErrorSignature as C, isConstructorSignature as I, isFallbackSignature as Z, isReceiveSignature as K, functionModifiers as d, execFunctionSignature as L, execEventSignature as U, eventModifiers as W, execErrorSignature as D, execConstructorSignature as V, execFallbackSignature as j } from "./index196.js";
+function ue(e, t = {}) {
+  if (T(e))
+    return q(e, t);
+  if (_(e))
+    return B(e, t);
+  if (C(e))
+    return G(e, t);
+  if (I(e))
+    return H(e, t);
+  if (Z(e))
+    return J(e);
+  if (K(e))
+    return {
+      type: "receive",
+      stateMutability: "payable"
+    };
+  throw new z({ signature: e });
+}
+function q(e, t = {}) {
+  const n = L(e);
+  if (!n)
+    throw new p({ signature: e, type: "function" });
+  const i = c(n.parameters), r = [], s = i.length;
+  for (let a = 0; a < s; a++)
+    r.push(l(i[a], {
+      modifiers: d,
+      structs: t,
+      type: "function"
+    }));
+  const o = [];
+  if (n.returns) {
+    const a = c(n.returns), u = a.length;
+    for (let f = 0; f < u; f++)
+      o.push(l(a[f], {
+        modifiers: d,
+        structs: t,
+        type: "function"
+      }));
+  }
+  return {
+    name: n.name,
+    type: "function",
+    stateMutability: n.stateMutability ?? "nonpayable",
+    inputs: r,
+    outputs: o
+  };
+}
+function B(e, t = {}) {
+  const n = U(e);
+  if (!n)
+    throw new p({ signature: e, type: "event" });
+  const i = c(n.parameters), r = [], s = i.length;
+  for (let o = 0; o < s; o++)
+    r.push(l(i[o], {
+      modifiers: W,
+      structs: t,
+      type: "event"
+    }));
+  return { name: n.name, type: "event", inputs: r };
+}
+function G(e, t = {}) {
+  const n = D(e);
+  if (!n)
+    throw new p({ signature: e, type: "error" });
+  const i = c(n.parameters), r = [], s = i.length;
+  for (let o = 0; o < s; o++)
+    r.push(l(i[o], { structs: t, type: "error" }));
+  return { name: n.name, type: "error", inputs: r };
+}
+function H(e, t = {}) {
+  const n = V(e);
+  if (!n)
+    throw new p({ signature: e, type: "constructor" });
+  const i = c(n.parameters), r = [], s = i.length;
+  for (let o = 0; o < s; o++)
+    r.push(l(i[o], { structs: t, type: "constructor" }));
+  return {
+    type: "constructor",
+    stateMutability: n.stateMutability ?? "nonpayable",
+    inputs: r
+  };
+}
+function J(e) {
+  const t = j(e);
+  if (!t)
+    throw new p({ signature: e, type: "fallback" });
+  return {
+    type: "fallback",
+    stateMutability: t.stateMutability ?? "nonpayable"
+  };
+}
+const N = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/, O = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/, Q = /^u?int$/;
+function l(e, t) {
+  const n = F(e, t?.type, t?.structs);
+  if (y.has(n))
+    return y.get(n);
+  const i = v.test(e), r = $(i ? O : N, e);
+  if (!r)
+    throw new P({ param: e });
+  if (r.name && ee(r.name))
+    throw new M({ param: e, name: r.name });
+  const s = r.name ? { name: r.name } : {}, o = r.modifier === "indexed" ? { indexed: !0 } : {}, a = t?.structs ?? {};
+  let u, f = {};
+  if (i) {
+    u = "tuple";
+    const g = c(r.type), b = [], x = g.length;
+    for (let m = 0; m < x; m++)
+      b.push(l(g[m], { structs: a }));
+    f = { components: b };
+  } else if (r.type in a)
+    u = "tuple", f = { components: a[r.type] };
+  else if (Q.test(r.type))
+    u = `${r.type}256`;
+  else if (u = r.type, t?.type !== "struct" && !X(u))
+    throw new E({ type: u });
+  if (r.modifier) {
+    if (!t?.modifiers?.has?.(r.modifier))
+      throw new R({
+        param: e,
+        type: t?.type,
+        modifier: r.modifier
+      });
+    if (d.has(r.modifier) && !te(u, !!r.array))
+      throw new k({
+        param: e,
+        type: t?.type,
+        modifier: r.modifier
+      });
+  }
+  const h = {
+    type: `${u}${r.array ?? ""}`,
+    ...s,
+    ...o,
+    ...f
+  };
+  return y.set(n, h), h;
+}
+function c(e, t = [], n = "", i = 0) {
+  const r = e.trim().length;
+  for (let s = 0; s < r; s++) {
+    const o = e[s], a = e.slice(s + 1);
+    switch (o) {
+      case ",":
+        return i === 0 ? c(a, [...t, n.trim()]) : c(a, t, `${n}${o}`, i);
+      case "(":
+        return c(a, t, `${n}${o}`, i + 1);
+      case ")":
+        return c(a, t, `${n}${o}`, i - 1);
+      default:
+        return c(a, t, `${n}${o}`, i);
+    }
+  }
+  if (n === "")
+    return t;
+  if (i !== 0)
+    throw new A({ current: n, depth: i });
+  return t.push(n.trim()), t;
+}
+function X(e) {
+  return e === "address" || e === "bool" || e === "function" || e === "string" || w.test(e) || S.test(e);
+}
+const Y = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
+function ee(e) {
+  return e === "address" || e === "bool" || e === "function" || e === "string" || e === "tuple" || w.test(e) || S.test(e) || Y.test(e);
+}
+function te(e, t) {
+  return t || e === "bytes" || e === "string" || e === "tuple";
+}
+export {
+  ee as isSolidityKeyword,
+  X as isSolidityType,
+  te as isValidDataLocation,
+  l as parseAbiParameter,
+  H as parseConstructorSignature,
+  G as parseErrorSignature,
+  B as parseEventSignature,
+  J as parseFallbackSignature,
+  q as parseFunctionSignature,
+  ue as parseSignature,
+  c as splitParameters
+};

package/dist/esm/index199.js

@@ -0,0 +1,25 @@
+import { InvalidAbiItemError as f } from "./index200.js";
+import { isStructSignature as p } from "./index196.js";
+import { parseStructs as c } from "./index197.js";
+import { parseSignature as i } from "./index198.js";
+function u(t) {
+  let r;
+  if (typeof t == "string")
+    r = i(t);
+  else {
+    const m = c(t), n = t.length;
+    for (let o = 0; o < n; o++) {
+      const e = t[o];
+      if (!p(e)) {
+        r = i(e, m);
+        break;
+      }
+    }
+  }
+  if (!r)
+    throw new f({ signature: t });
+  return r;
+}
+export {
+  u as parseAbiItem
+};

package/dist/esm/index20.js

@@ -0,0 +1,43 @@
+import { universalResolverReverseAbi as f } from "./index71.js";
+import { getChainContractAddress as u } from "./index172.js";
+import { toHex as h } from "./index108.js";
+import { isNullUniversalResolverError as p } from "./index209.js";
+import { packetToBytes as C } from "./index210.js";
+import { getAction as w } from "./index211.js";
+import { readContract as A } from "./index54.js";
+async function b(e, { address: t, blockNumber: s, blockTag: i, gatewayUrls: a, strict: c, universalResolverAddress: d }) {
+  let o = d;
+  if (!o) {
+    if (!e.chain)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    o = u({
+      blockNumber: s,
+      chain: e.chain,
+      contract: "ensUniversalResolver"
+    });
+  }
+  const v = `${t.toLowerCase().substring(2)}.addr.reverse`;
+  try {
+    const r = {
+      address: o,
+      abi: f,
+      functionName: "reverse",
+      args: [h(C(v))],
+      blockNumber: s,
+      blockTag: i
+    }, n = w(e, A, "readContract"), [l, m] = a ? await n({
+      ...r,
+      args: [...r.args, a]
+    }) : await n(r);
+    return t.toLowerCase() !== m.toLowerCase() ? null : l;
+  } catch (r) {
+    if (c)
+      throw r;
+    if (p(r, "reverse"))
+      return null;
+    throw r;
+  }
+}
+export {
+  b as getEnsName
+};

package/dist/esm/index200.js

@@ -0,0 +1,45 @@
+import { BaseError as r } from "./index189.js";
+class a extends r {
+  constructor({ signature: e }) {
+    super("Failed to parse ABI item.", {
+      details: `parseAbiItem(${JSON.stringify(e, null, 2)})`,
+      docsPath: "/api/human#parseabiitem-1"
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "InvalidAbiItemError"
+    });
+  }
+}
+class o extends r {
+  constructor({ type: e }) {
+    super("Unknown type.", {
+      metaMessages: [
+        `Type "${e}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
+      ]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "UnknownTypeError"
+    });
+  }
+}
+class i extends r {
+  constructor({ type: e }) {
+    super("Unknown type.", {
+      metaMessages: [`Type "${e}" is not a valid ABI type.`]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "UnknownSolidityTypeError"
+    });
+  }
+}
+export {
+  a as InvalidAbiItemError,
+  i as UnknownSolidityTypeError,
+  o as UnknownTypeError
+};

package/dist/esm/index201.js

@@ -0,0 +1,79 @@
+import { BaseError as t } from "./index189.js";
+class n extends t {
+  constructor({ param: e }) {
+    super("Invalid ABI parameter.", {
+      details: e
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "InvalidParameterError"
+    });
+  }
+}
+class s extends t {
+  constructor({ param: e, name: r }) {
+    super("Invalid ABI parameter.", {
+      details: e,
+      metaMessages: [
+        `"${r}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
+      ]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "SolidityProtectedKeywordError"
+    });
+  }
+}
+class l extends t {
+  constructor({ param: e, type: r, modifier: i }) {
+    super("Invalid ABI parameter.", {
+      details: e,
+      metaMessages: [
+        `Modifier "${i}" not allowed${r ? ` in "${r}" type` : ""}.`
+      ]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "InvalidModifierError"
+    });
+  }
+}
+class d extends t {
+  constructor({ param: e, type: r, modifier: i }) {
+    super("Invalid ABI parameter.", {
+      details: e,
+      metaMessages: [
+        `Modifier "${i}" not allowed${r ? ` in "${r}" type` : ""}.`,
+        `Data location can only be specified for array, struct, or mapping types, but "${i}" was given.`
+      ]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "InvalidFunctionModifierError"
+    });
+  }
+}
+class u extends t {
+  constructor({ abiParameter: e }) {
+    super("Invalid ABI parameter.", {
+      details: JSON.stringify(e, null, 2),
+      metaMessages: ["ABI parameter type is invalid."]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "InvalidAbiTypeParameterError"
+    });
+  }
+}
+export {
+  u as InvalidAbiTypeParameterError,
+  d as InvalidFunctionModifierError,
+  l as InvalidModifierError,
+  n as InvalidParameterError,
+  s as SolidityProtectedKeywordError
+};

package/dist/esm/index202.js

@@ -0,0 +1,43 @@
+import { BaseError as r } from "./index189.js";
+class u extends r {
+  constructor({ signature: e, type: n }) {
+    super(`Invalid ${n} signature.`, {
+      details: e
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "InvalidSignatureError"
+    });
+  }
+}
+class i extends r {
+  constructor({ signature: e }) {
+    super("Unknown signature.", {
+      details: e
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "UnknownSignatureError"
+    });
+  }
+}
+class s extends r {
+  constructor({ signature: e }) {
+    super("Invalid struct signature.", {
+      details: e,
+      metaMessages: ["No properties exist."]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "InvalidStructSignatureError"
+    });
+  }
+}
+export {
+  u as InvalidSignatureError,
+  s as InvalidStructSignatureError,
+  i as UnknownSignatureError
+};

package/dist/esm/index203.js

@@ -0,0 +1,19 @@
+import { BaseError as s } from "./index189.js";
+class n extends s {
+  constructor({ current: r, depth: e }) {
+    super("Unbalanced parentheses.", {
+      metaMessages: [
+        `"${r.trim()}" has too many ${e > 0 ? "opening" : "closing"} parentheses.`
+      ],
+      details: `Depth "${e}"`
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "InvalidParenthesisError"
+    });
+  }
+}
+export {
+  n as InvalidParenthesisError
+};

package/dist/esm/index204.js

@@ -0,0 +1,16 @@
+import { BaseError as r } from "./index189.js";
+class a extends r {
+  constructor({ type: e }) {
+    super("Circular reference detected.", {
+      metaMessages: [`Struct "${e}" is a circular reference.`]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "CircularReferenceError"
+    });
+  }
+}
+export {
+  a as CircularReferenceError
+};

package/dist/esm/index205.js

@@ -0,0 +1,39 @@
+const f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+let w = 0;
+function C(s, l, h) {
+  const i = ++w, c = () => f.get(s) || [], g = () => {
+    const n = c();
+    f.set(s, n.filter((e) => e.id !== i));
+  }, r = () => {
+    const n = c();
+    if (!n.some((t) => t.id === i))
+      return;
+    const e = p.get(s);
+    if (n.length === 1 && e) {
+      const t = e();
+      t instanceof Promise && t.catch(() => {
+      });
+    }
+    g();
+  }, o = c();
+  if (f.set(s, [
+    ...o,
+    { id: i, fns: l }
+  ]), o && o.length > 0)
+    return r;
+  const u = {};
+  for (const n in l)
+    u[n] = (...e) => {
+      const t = c();
+      if (t.length !== 0)
+        for (const m of t)
+          m.fns[n]?.(...e);
+    };
+  const a = h(u);
+  return typeof a == "function" && p.set(s, a), r;
+}
+export {
+  p as cleanupCache,
+  f as listenersCache,
+  C as observe
+};

package/dist/esm/index206.js

@@ -0,0 +1,18 @@
+import { wait as l } from "./index175.js";
+function p(a, { emitOnBegin: e, initialWaitTime: w, interval: i }) {
+  let n = !0;
+  const t = () => n = !1;
+  return (async () => {
+    let o;
+    e && (o = await a({ unpoll: t }));
+    const u = await w?.(o) ?? i;
+    await l(u);
+    const c = async () => {
+      n && (await a({ unpoll: t }), await l(i), c());
+    };
+    c();
+  })(), t;
+}
+export {
+  p as poll
+};

package/dist/esm/index207.js

@@ -0,0 +1,11 @@
+function i() {
+  let e = () => {
+  }, n = () => {
+  };
+  return { promise: new Promise((r, o) => {
+    e = r, n = o;
+  }), resolve: e, reject: n };
+}
+export {
+  i as withResolvers
+};

package/dist/esm/index208.js

@@ -0,0 +1,15 @@
+function r() {
+  return {
+    current: 0,
+    take() {
+      return this.current++;
+    },
+    reset() {
+      this.current = 0;
+    }
+  };
+}
+const t = /* @__PURE__ */ r();
+export {
+  t as idCache
+};

package/dist/esm/index209.js

@@ -0,0 +1,12 @@
+import { panicReasons as a } from "./index85.js";
+import { BaseError as s } from "./index81.js";
+import { ContractFunctionRevertedError as t } from "./index84.js";
+function d(e, o) {
+  if (!(e instanceof s))
+    return !1;
+  const r = e.walk((n) => n instanceof t);
+  return r instanceof t ? !!(r.data?.errorName === "ResolverNotFound" || r.data?.errorName === "ResolverWildcardNotSupported" || r.data?.errorName === "ResolverNotContract" || r.data?.errorName === "ResolverError" || r.data?.errorName === "HttpError" || r.reason?.includes("Wildcard on non-extended resolvers is not supported") || o === "reverse" && r.reason === a[50]) : !1;
+}
+export {
+  d as isNullUniversalResolverError
+};

package/dist/esm/index21.js

@@ -0,0 +1,40 @@
+import { getChainContractAddress as l } from "./index172.js";
+import { toHex as u } from "./index108.js";
+import { packetToBytes as v } from "./index210.js";
+import { getAction as f } from "./index211.js";
+import { readContract as m } from "./index54.js";
+async function A(o, r) {
+  const { blockNumber: n, blockTag: i, name: s } = r, { chain: e } = o, a = (() => {
+    if (r.universalResolverAddress)
+      return r.universalResolverAddress;
+    if (!e)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    return l({
+      blockNumber: n,
+      chain: e,
+      contract: "ensUniversalResolver"
+    });
+  })(), t = e?.ensTlds;
+  if (t && !t.some((c) => s.endsWith(c)))
+    throw new Error(`${s} is not a valid ENS TLD (${t?.join(", ")}) for chain "${e.name}" (id: ${e.id}).`);
+  const [d] = await f(o, m, "readContract")({
+    address: a,
+    abi: [
+      {
+        inputs: [{ type: "bytes" }],
+        name: "findResolver",
+        outputs: [{ type: "address" }, { type: "bytes32" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ],
+    functionName: "findResolver",
+    args: [u(v(s))],
+    blockNumber: n,
+    blockTag: i
+  });
+  return d;
+}
+export {
+  A as getEnsResolver
+};

package/dist/esm/index210.js

@@ -0,0 +1,19 @@
+import { stringToBytes as i } from "./index107.js";
+import { encodeLabelhash as h } from "./index243.js";
+import { labelhash as f } from "./index106.js";
+function y(s) {
+  const o = s.replace(/^\.|\.$/gm, "");
+  if (o.length === 0)
+    return new Uint8Array(1);
+  const e = new Uint8Array(i(o).byteLength + 2);
+  let t = 0;
+  const l = o.split(".");
+  for (let r = 0; r < l.length; r++) {
+    let n = i(l[r]);
+    n.byteLength > 255 && (n = i(h(f(l[r])))), e[t] = n.length, e.set(n, t + 1), t += n.length + 1;
+  }
+  return e.byteLength !== t + 1 ? e.slice(0, t + 1) : e;
+}
+export {
+  y as packetToBytes
+};