@coinbase/cdp-hooks 0.0.34 → 0.0.35

package/dist/esm/index20.js

@@ -1,27 +1,113 @@
-import { parseAvatarRecord as m } from "./index214.js";
-import { getAction as u } from "./index206.js";
-import { getEnsText as f } from "./index23.js";
-async function y(t, { blockNumber: a, blockTag: e, assetGatewayUrls: n, name: o, gatewayUrls: c, strict: i, universalResolverAddress: s }) {
-  const r = await u(t, f, "getEnsText")({
-    blockNumber: a,
-    blockTag: e,
-    key: "avatar",
-    name: o,
-    universalResolverAddress: s,
-    gatewayUrls: c,
-    strict: i
-  });
-  if (!r)
-    return null;
-  try {
-    return await m(t, {
-      record: r,
-      gatewayUrls: n
-    });
-  } catch {
-    return null;
-  }
+import { getEnsAddress as a } from "./index21.js";
+import { getEnsAvatar as m } from "./index22.js";
+import { getEnsName as s } from "./index23.js";
+import { getEnsResolver as i } from "./index24.js";
+import { getEnsText as g } from "./index25.js";
+import { call as p } from "./index26.js";
+import { createAccessList as f } from "./index27.js";
+import { createBlockFilter as n } from "./index28.js";
+import { createContractEventFilter as c } from "./index29.js";
+import { createEventFilter as C } from "./index30.js";
+import { createPendingTransactionFilter as u } from "./index31.js";
+import { estimateContractGas as F } from "./index32.js";
+import { estimateFeesPerGas as T } from "./index33.js";
+import { estimateGas as E } from "./index34.js";
+import { estimateMaxPriorityFeePerGas as B } from "./index35.js";
+import { getBalance as v } from "./index36.js";
+import { getBlobBaseFee as d } from "./index37.js";
+import { getBlock as w } from "./index38.js";
+import { getBlockNumber as h } from "./index39.js";
+import { getBlockTransactionCount as k } from "./index40.js";
+import { getChainId as P } from "./index41.js";
+import { getCode as o } from "./index42.js";
+import { getContractEvents as y } from "./index43.js";
+import { getEip712Domain as G } from "./index44.js";
+import { getFeeHistory as R } from "./index45.js";
+import { getFilterChanges as A } from "./index46.js";
+import { getFilterLogs as b } from "./index47.js";
+import { getGasPrice as l } from "./index48.js";
+import { getLogs as L } from "./index49.js";
+import { getProof as M } from "./index50.js";
+import { getStorageAt as N } from "./index51.js";
+import { getTransaction as x } from "./index52.js";
+import { getTransactionConfirmations as D } from "./index53.js";
+import { getTransactionCount as S } from "./index54.js";
+import { getTransactionReceipt as q } from "./index55.js";
+import { multicall as H } from "./index56.js";
+import { readContract as I } from "./index57.js";
+import { simulateBlocks as e } from "./index58.js";
+import { simulateCalls as j } from "./index59.js";
+import { simulateContract as z } from "./index60.js";
+import { uninstallFilter as J } from "./index61.js";
+import { verifyMessage as K } from "./index62.js";
+import { verifyTypedData as O } from "./index63.js";
+import { waitForTransactionReceipt as Q } from "./index64.js";
+import { watchBlockNumber as U } from "./index65.js";
+import { watchBlocks as V } from "./index66.js";
+import { watchContractEvent as W } from "./index67.js";
+import { watchEvent as X } from "./index68.js";
+import { watchPendingTransactions as Y } from "./index69.js";
+import { verifySiweMessage as Z } from "./index70.js";
+import { prepareTransactionRequest as _ } from "./index71.js";
+import { sendRawTransaction as $ } from "./index72.js";
+function _r(t) {
+  return {
+    call: (r) => p(t, r),
+    createAccessList: (r) => f(t, r),
+    createBlockFilter: () => n(t),
+    createContractEventFilter: (r) => c(t, r),
+    createEventFilter: (r) => C(t, r),
+    createPendingTransactionFilter: () => u(t),
+    estimateContractGas: (r) => F(t, r),
+    estimateGas: (r) => E(t, r),
+    getBalance: (r) => v(t, r),
+    getBlobBaseFee: () => d(t),
+    getBlock: (r) => w(t, r),
+    getBlockNumber: (r) => h(t, r),
+    getBlockTransactionCount: (r) => k(t, r),
+    getBytecode: (r) => o(t, r),
+    getChainId: () => P(t),
+    getCode: (r) => o(t, r),
+    getContractEvents: (r) => y(t, r),
+    getEip712Domain: (r) => G(t, r),
+    getEnsAddress: (r) => a(t, r),
+    getEnsAvatar: (r) => m(t, r),
+    getEnsName: (r) => s(t, r),
+    getEnsResolver: (r) => i(t, r),
+    getEnsText: (r) => g(t, r),
+    getFeeHistory: (r) => R(t, r),
+    estimateFeesPerGas: (r) => T(t, r),
+    getFilterChanges: (r) => A(t, r),
+    getFilterLogs: (r) => b(t, r),
+    getGasPrice: () => l(t),
+    getLogs: (r) => L(t, r),
+    getProof: (r) => M(t, r),
+    estimateMaxPriorityFeePerGas: (r) => B(t, r),
+    getStorageAt: (r) => N(t, r),
+    getTransaction: (r) => x(t, r),
+    getTransactionConfirmations: (r) => D(t, r),
+    getTransactionCount: (r) => S(t, r),
+    getTransactionReceipt: (r) => q(t, r),
+    multicall: (r) => H(t, r),
+    prepareTransactionRequest: (r) => _(t, r),
+    readContract: (r) => I(t, r),
+    sendRawTransaction: (r) => $(t, r),
+    simulate: (r) => e(t, r),
+    simulateBlocks: (r) => e(t, r),
+    simulateCalls: (r) => j(t, r),
+    simulateContract: (r) => z(t, r),
+    verifyMessage: (r) => K(t, r),
+    verifySiweMessage: (r) => Z(t, r),
+    verifyTypedData: (r) => O(t, r),
+    uninstallFilter: (r) => J(t, r),
+    waitForTransactionReceipt: (r) => Q(t, r),
+    watchBlocks: (r) => V(t, r),
+    watchBlockNumber: (r) => U(t, r),
+    watchContractEvent: (r) => W(t, r),
+    watchEvent: (r) => X(t, r),
+    watchPendingTransactions: (r) => Y(t, r)
+  };
 }
 export {
-  y as getEnsAvatar
+  _r as publicActions
 };

package/dist/esm/index200.js

@@ -1,25 +1,69 @@
-import { InvalidAbiItemError as f } from "./index201.js";
-import { isStructSignature as p } from "./index197.js";
-import { parseStructs as c } from "./index198.js";
-import { parseSignature as i } from "./index199.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;
+import { execTyped as t } from "./index198.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 {
-  u as parseAbiItem
+  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/index201.js

@@ -1,45 +1,68 @@
-import { BaseError as r } from "./index190.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"
-    });
+import { isTupleRegex as g, execTyped as w } from "./index198.js";
+import { UnknownTypeError as S } from "./index204.js";
+import { InvalidAbiTypeParameterError as d } from "./index205.js";
+import { InvalidSignatureError as T, InvalidStructSignatureError as v } from "./index206.js";
+import { CircularReferenceError as x } from "./index208.js";
+import { isStructSignature as E, execStructSignature as b } from "./index200.js";
+import { parseAbiParameter as A, isSolidityType as $ } from "./index202.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;
   }
-}
-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"
-    });
+  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;
 }
-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"
-    });
+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 {
-  a as InvalidAbiItemError,
-  i as UnknownSolidityTypeError,
-  o as UnknownTypeError
+  C as parseStructs
 };

package/dist/esm/index202.js

@@ -1,79 +1,188 @@
-import { BaseError as t } from "./index190.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"
-    });
-  }
+import { execTyped as $, bytesRegex as w, integerRegex as S, isTupleRegex as v } from "./index198.js";
+import { UnknownSolidityTypeError as E } from "./index204.js";
+import { InvalidParameterError as P, SolidityProtectedKeywordError as M, InvalidModifierError as R, InvalidFunctionModifierError as k } from "./index205.js";
+import { UnknownSignatureError as z, InvalidSignatureError as p } from "./index206.js";
+import { InvalidParenthesisError as A } from "./index207.js";
+import { getParameterCacheKey as F, parameterCache as y } from "./index243.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 "./index200.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 });
 }
-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"
-    });
+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
+  };
 }
-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"
-    });
-  }
+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
+  };
 }
-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"
-    });
+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;
 }
-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"
-    });
+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 {
-  u as InvalidAbiTypeParameterError,
-  d as InvalidFunctionModifierError,
-  l as InvalidModifierError,
-  n as InvalidParameterError,
-  s as SolidityProtectedKeywordError
+  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/index203.js

@@ -1,43 +1,25 @@
-import { BaseError as r } from "./index190.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"
-    });
+import { InvalidAbiItemError as f } from "./index204.js";
+import { isStructSignature as p } from "./index200.js";
+import { parseStructs as c } from "./index201.js";
+import { parseSignature as i } from "./index202.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 InvalidSignatureError,
-  s as InvalidStructSignatureError,
-  i as UnknownSignatureError
+  u as parseAbiItem
 };