@coinbase/cdp-hooks 0.0.86 → 0.0.87

package/dist/esm/index258.js

@@ -1,38 +1,13 @@
-import { hexToBigInt as n } from "./index206.js";
-import { defineBlock as r } from "./index178.js";
-import { defineTransaction as s, formatTransaction as m } from "./index180.js";
-import { defineTransactionReceipt as l } from "./index207.js";
-const p = {
-  block: /* @__PURE__ */ r({
-    format(e) {
-      return {
-        transactions: e.transactions?.map((t) => {
-          if (typeof t == "string")
-            return t;
-          const i = m(t);
-          return i.typeHex === "0x7e" && (i.isSystemTx = t.isSystemTx, i.mint = t.mint ? n(t.mint) : void 0, i.sourceHash = t.sourceHash, i.type = "deposit"), i;
-        }),
-        stateRoot: e.stateRoot
-      };
-    }
-  }),
-  transaction: /* @__PURE__ */ s({
-    format(e) {
-      const o = {};
-      return e.type === "0x7e" && (o.isSystemTx = e.isSystemTx, o.mint = e.mint ? n(e.mint) : void 0, o.sourceHash = e.sourceHash, o.type = "deposit"), o;
-    }
-  }),
-  transactionReceipt: /* @__PURE__ */ l({
-    format(e) {
-      return {
-        l1GasPrice: e.l1GasPrice ? n(e.l1GasPrice) : null,
-        l1GasUsed: e.l1GasUsed ? n(e.l1GasUsed) : null,
-        l1Fee: e.l1Fee ? n(e.l1Fee) : null,
-        l1FeeScalar: e.l1FeeScalar ? Number(e.l1FeeScalar) : null
-      };
-    }
-  })
-};
+import { formatAbiParameter as m } from "./index259.js";
+function f(e) {
+  let r = "";
+  const o = e.length;
+  for (let t = 0; t < o; t++) {
+    const a = e[t];
+    r += m(a), t !== o - 1 && (r += ", ");
+  }
+  return r;
+}
 export {
-  p as formatters
+  f as formatAbiParameters
 };

package/dist/esm/index259.js

@@ -1,44 +1,22 @@
-import { InvalidAddressError as a } from "./index168.js";
-import { isAddress as f } from "./index195.js";
-import { concatHex as p } from "./index177.js";
-import { toHex as i } from "./index173.js";
-import { toRlp as x } from "./index218.js";
-import { serializeTransaction as l } from "./index250.js";
-function T(r, e) {
-  return h(r) ? z(r) : l(r, e);
-}
-const E = {
-  transaction: T
-};
-function z(r) {
-  w(r);
-  const { sourceHash: e, data: o, from: m, gas: t, isSystemTx: u, mint: s, to: c, value: n } = r, d = [
-    e,
-    m,
-    c ?? "0x",
-    s ? i(s) : "0x",
-    n ? i(n) : "0x",
-    t ? i(t) : "0x",
-    u ? "0x1" : "0x",
-    o ?? "0x"
-  ];
-  return p([
-    "0x7e",
-    x(d)
-  ]);
-}
-function h(r) {
-  return r.type === "deposit" || typeof r.sourceHash < "u";
-}
-function w(r) {
-  const { from: e, to: o } = r;
-  if (e && !f(e))
-    throw new a({ address: e });
-  if (o && !f(o))
-    throw new a({ address: o });
+import { execTyped as f } from "./index260.js";
+const p = /^tuple(?<array>(\[(\d*)\])*)$/;
+function c(n) {
+  let t = n.type;
+  if (p.test(n.type) && "components" in n) {
+    t = "(";
+    const e = n.components.length;
+    for (let o = 0; o < e; o++) {
+      const d = n.components[o];
+      t += c(d), o < e - 1 && (t += ", ");
+    }
+    const s = f(p, n.type);
+    return t += `)${s?.array ?? ""}`, c({
+      ...n,
+      type: t
+    });
+  }
+  return "indexed" in n && n.indexed && (t = `${t} indexed`), n.name ? `${t} ${n.name}` : t;
 }
 export {
-  w as assertTransactionDeposit,
-  T as serializeTransaction,
-  E as serializers
+  c as formatAbiParameter
 };

package/dist/esm/index26.js

@@ -1,6 +1,6 @@
 import { signEvmMessage as e } from "@coinbase/cdp-core";
 import "./index2.js";
-import { useSendHookCallOnce as s } from "./index62.js";
+import { useSendHookCallOnce as s } from "./index65.js";
 import "react";
 import { useEnforceAuthenticated as m } from "./index33.js";
 const a = () => (s("use_sign_evm_message"), { signEvmMessage: m(e) });

package/dist/esm/index260.js

@@ -1,43 +1,10 @@
-import { version as u } from "./index261.js";
-class a extends Error {
-  constructor(i, e = {}) {
-    const t = e.cause instanceof a ? e.cause.details : e.cause?.message ? e.cause.message : e.details, s = e.cause instanceof a && e.cause.docsPath || e.docsPath, r = [
-      i || "An error occurred.",
-      "",
-      ...e.metaMessages ? [...e.metaMessages, ""] : [],
-      ...s ? [`Docs: https://abitype.dev${s}`] : [],
-      ...t ? [`Details: ${t}`] : [],
-      `Version: abitype@${u}`
-    ].join(`
-`);
-    super(r), Object.defineProperty(this, "details", {
-      enumerable: !0,
-      configurable: !0,
-      writable: !0,
-      value: void 0
-    }), Object.defineProperty(this, "docsPath", {
-      enumerable: !0,
-      configurable: !0,
-      writable: !0,
-      value: void 0
-    }), Object.defineProperty(this, "metaMessages", {
-      enumerable: !0,
-      configurable: !0,
-      writable: !0,
-      value: void 0
-    }), Object.defineProperty(this, "shortMessage", {
-      enumerable: !0,
-      configurable: !0,
-      writable: !0,
-      value: void 0
-    }), Object.defineProperty(this, "name", {
-      enumerable: !0,
-      configurable: !0,
-      writable: !0,
-      value: "AbiTypeError"
-    }), e.cause && (this.cause = e.cause), this.details = t, this.docsPath = s, this.metaMessages = e.metaMessages, this.shortMessage = i;
-  }
+function n(e, t) {
+  return e.exec(t)?.groups;
 }
+const s = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/, o = /^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)?$/, x = /^\(.+?\).*?$/;
 export {
-  a as BaseError
+  s as bytesRegex,
+  n as execTyped,
+  o as integerRegex,
+  x as isTupleRegex
 };

package/dist/esm/index261.js

@@ -1,4 +1,14 @@
-const o = "1.0.8";
+import { isStructSignature as c } from "./index262.js";
+import { parseStructs as s } from "./index263.js";
+import { parseSignature as p } from "./index264.js";
+function a(t) {
+  const i = s(t), o = [], e = t.length;
+  for (let r = 0; r < e; r++) {
+    const n = t[r];
+    c(n) || o.push(p(n, i));
+  }
+  return o;
+}
 export {
-  o as version
+  a as parseAbi
 };

package/dist/esm/index262.js

@@ -1,7 +1,69 @@
-import { formatAbiParameters as r } from "./index263.js";
-function e(t) {
-  return t.type === "function" ? `function ${t.name}(${r(t.inputs)})${t.stateMutability && t.stateMutability !== "nonpayable" ? ` ${t.stateMutability}` : ""}${t.outputs?.length ? ` returns (${r(t.outputs)})` : ""}` : t.type === "event" ? `event ${t.name}(${r(t.inputs)})` : t.type === "error" ? `error ${t.name}(${r(t.inputs)})` : t.type === "constructor" ? `constructor(${r(t.inputs)})${t.stateMutability === "payable" ? " payable" : ""}` : t.type === "fallback" ? `fallback() external${t.stateMutability === "payable" ? " payable" : ""}` : "receive() external payable";
+import { execTyped as t } from "./index260.js";
+const n = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+function g(e) {
+  return n.test(e);
 }
+function S(e) {
+  return t(n, e);
+}
+const r = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+function l(e) {
+  return r.test(e);
+}
+function f(e) {
+  return t(r, e);
+}
+const a = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
+function x(e) {
+  return a.test(e);
+}
+function p(e) {
+  return t(a, e);
+}
+const u = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
+function $(e) {
+  return u.test(e);
+}
+function b(e) {
+  return t(u, e);
+}
+const i = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
+function m(e) {
+  return i.test(e);
+}
+function y(e) {
+  return t(i, e);
+}
+const c = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
+function v(e) {
+  return c.test(e);
+}
+function z(e) {
+  return t(c, e);
+}
+const o = /^receive\(\) external payable$/;
+function A(e) {
+  return o.test(e);
+}
+const R = /* @__PURE__ */ new Set(["indexed"]), Z = /* @__PURE__ */ new Set([
+  "calldata",
+  "memory",
+  "storage"
+]);
 export {
-  e as formatAbiItem
+  R as eventModifiers,
+  y as execConstructorSignature,
+  S as execErrorSignature,
+  f as execEventSignature,
+  z as execFallbackSignature,
+  p as execFunctionSignature,
+  b as execStructSignature,
+  Z as functionModifiers,
+  m as isConstructorSignature,
+  g as isErrorSignature,
+  l as isEventSignature,
+  v as isFallbackSignature,
+  x as isFunctionSignature,
+  A as isReceiveSignature,
+  $ as isStructSignature
 };

package/dist/esm/index263.js

@@ -1,13 +1,68 @@
-import { formatAbiParameter as m } from "./index264.js";
-function f(e) {
-  let r = "";
-  const o = e.length;
-  for (let t = 0; t < o; t++) {
-    const a = e[t];
-    r += m(a), t !== o - 1 && (r += ", ");
+import { isTupleRegex as g, execTyped as w } from "./index260.js";
+import { UnknownTypeError as S } from "./index266.js";
+import { InvalidAbiTypeParameterError as d } from "./index267.js";
+import { InvalidSignatureError as T, InvalidStructSignatureError as v } from "./index268.js";
+import { CircularReferenceError as x } from "./index270.js";
+import { isStructSignature as E, execStructSignature as b } from "./index262.js";
+import { parseAbiParameter as A, isSolidityType as $ } from "./index264.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;
   }
-  return r;
+  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 {
-  f as formatAbiParameters
+  C as parseStructs
 };

package/dist/esm/index264.js

@@ -1,22 +1,188 @@
-import { execTyped as f } from "./index265.js";
-const p = /^tuple(?<array>(\[(\d*)\])*)$/;
-function c(n) {
-  let t = n.type;
-  if (p.test(n.type) && "components" in n) {
-    t = "(";
-    const e = n.components.length;
-    for (let o = 0; o < e; o++) {
-      const d = n.components[o];
-      t += c(d), o < e - 1 && (t += ", ");
+import { execTyped as $, bytesRegex as w, integerRegex as S, isTupleRegex as v } from "./index260.js";
+import { UnknownSolidityTypeError as E } from "./index266.js";
+import { InvalidParameterError as P, SolidityProtectedKeywordError as M, InvalidModifierError as R, InvalidFunctionModifierError as k } from "./index267.js";
+import { UnknownSignatureError as z, InvalidSignatureError as p } from "./index268.js";
+import { InvalidParenthesisError as A } from "./index269.js";
+import { getParameterCacheKey as F, parameterCache as y } from "./index313.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 "./index262.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);
     }
-    const s = f(p, n.type);
-    return t += `)${s?.array ?? ""}`, c({
-      ...n,
-      type: t
-    });
   }
-  return "indexed" in n && n.indexed && (t = `${t} indexed`), n.name ? `${t} ${n.name}` : t;
+  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 {
-  c as formatAbiParameter
+  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/index265.js

@@ -1,10 +1,25 @@
-function n(e, t) {
-  return e.exec(t)?.groups;
+import { InvalidAbiItemError as f } from "./index266.js";
+import { isStructSignature as p } from "./index262.js";
+import { parseStructs as c } from "./index263.js";
+import { parseSignature as i } from "./index264.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;
 }
-const s = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/, o = /^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)?$/, x = /^\(.+?\).*?$/;
 export {
-  s as bytesRegex,
-  n as execTyped,
-  o as integerRegex,
-  x as isTupleRegex
+  u as parseAbiItem
 };

package/dist/esm/index266.js

@@ -1,14 +1,45 @@
-import { isStructSignature as c } from "./index267.js";
-import { parseStructs as s } from "./index268.js";
-import { parseSignature as p } from "./index269.js";
-function a(t) {
-  const i = s(t), o = [], e = t.length;
-  for (let r = 0; r < e; r++) {
-    const n = t[r];
-    c(n) || o.push(p(n, i));
+import { BaseError as r } from "./index255.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"
+    });
   }
-  return o;
 }
 export {
-  a as parseAbi
+  a as InvalidAbiItemError,
+  i as UnknownSolidityTypeError,
+  o as UnknownTypeError
 };