@coinbase/cdp-hooks 0.0.17 → 0.0.19

package/dist/esm/index261.js

@@ -0,0 +1,80 @@
+import { fromString as d } from "./index264.js";
+import { checksum as o } from "./index267.js";
+import { BaseError as c } from "./index256.js";
+import { keccak256 as f } from "./index259.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()
+      });
+  }
+}
+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 k(r, t = {}) {
+  const { strict: s = !0 } = t ?? {};
+  try {
+    return u(r, { strict: s }), !0;
+  } catch {
+    return !1;
+  }
+}
+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"
+    });
+  }
+}
+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"
+    });
+  }
+}
+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"
+    });
+  }
+}
+export {
+  i as InvalidAddressError,
+  p as InvalidChecksumError,
+  h as InvalidInputError,
+  u as assert,
+  m as checksum,
+  k as validate
+};

package/dist/esm/index262.js

@@ -0,0 +1,6 @@
+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)?$/;
+export {
+  e as arrayRegex,
+  t as bytesRegex,
+  n as integerRegex
+};

package/dist/esm/index263.js

@@ -0,0 +1,197 @@
+import { InvalidTypeError as g, InvalidArrayError as b, ArrayLengthMismatchError as w, BytesSizeMismatchError as z } from "./index249.js";
+import { assert as x } from "./index261.js";
+import { BaseError as S } from "./index256.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 "./index244.js";
+import { integerRegex as L } from "./index262.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;
+}
+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(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 N(e, n) {
+  const { checksum: r = !1 } = n;
+  return x(e, { strict: r }), {
+    dynamic: !1,
+    encoded: h(e.toLowerCase())
+  };
+}
+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 $(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 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 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
+    })
+  };
+}
+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)));
+  return {
+    dynamic: !0,
+    encoded: p(y(f(d(n), { size: 32 })), ...t)
+  };
+}
+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);
+  }
+  return {
+    dynamic: o,
+    encoded: o ? l(i) : p(...i.map(({ encoded: c }) => c))
+  };
+}
+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;
+}
+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
+};

package/dist/esm/index264.js

@@ -0,0 +1,66 @@
+import { BaseError as c } from "./index256.js";
+import { padRight as h } from "./index244.js";
+import { charCodeToBase16 as b, assertSize as g, pad as m } from "./index265.js";
+import { assertSize as p } from "./index258.js";
+const l = /* @__PURE__ */ new TextEncoder();
+function E(e) {
+  return e instanceof Uint8Array ? e : typeof e == "string" ? y(e) : z(e);
+}
+function z(e) {
+  return e instanceof Uint8Array ? e : new Uint8Array(e);
+}
+function y(e, t = {}) {
+  const { size: r } = t;
+  let n = e;
+  r && (p(e, r), n = h(e, r));
+  let i = n.slice(2);
+  i.length % 2 && (i = `0${i}`);
+  const f = i.length / 2, a = new Uint8Array(f);
+  for (let s = 0, o = 0; s < f; s++) {
+    const d = b(i.charCodeAt(o++)), u = b(i.charCodeAt(o++));
+    if (d === void 0 || u === void 0)
+      throw new c(`Invalid byte sequence ("${i[o - 2]}${i[o - 1]}" in "${i}").`);
+    a[s] = d * 16 + u;
+  }
+  return a;
+}
+function C(e, t = {}) {
+  const { size: r } = t, n = l.encode(e);
+  return typeof r == "number" ? (g(n, r), x(n, r)) : n;
+}
+function x(e, t) {
+  return m(e, { dir: "right", size: t });
+}
+function U(e) {
+  return e.length;
+}
+class B extends c {
+  constructor({ givenSize: t, maxSize: r }) {
+    super(`Size cannot exceed \`${r}\` bytes. Given size: \`${t}\` bytes.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Bytes.SizeOverflowError"
+    });
+  }
+}
+class O extends c {
+  constructor({ size: t, targetSize: r, type: n }) {
+    super(`${n.charAt(0).toUpperCase()}${n.slice(1).toLowerCase()} size (\`${t}\`) exceeds padding size (\`${r}\`).`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Bytes.SizeExceedsPaddingSizeError"
+    });
+  }
+}
+export {
+  O as SizeExceedsPaddingSizeError,
+  B as SizeOverflowError,
+  E as from,
+  z as fromArray,
+  y as fromHex,
+  C as fromString,
+  x as padRight,
+  U as size
+};

package/dist/esm/index265.js

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

package/dist/esm/index266.js

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

package/dist/esm/index267.js

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

package/dist/esm/index268.js

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

package/dist/esm/index269.js

@@ -0,0 +1,24 @@
+class r extends Map {
+  constructor(e) {
+    super(), Object.defineProperty(this, "maxSize", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.maxSize = e;
+  }
+  get(e) {
+    const t = super.get(e);
+    return super.has(e) && t !== void 0 && (this.delete(e), super.set(e, t)), t;
+  }
+  set(e, t) {
+    if (super.set(e, t), this.maxSize && this.size > this.maxSize) {
+      const s = this.keys().next().value;
+      s && this.delete(s);
+    }
+    return this;
+  }
+}
+export {
+  r as LruMap
+};

package/dist/esm/index27.js

@@ -0,0 +1,39 @@
+import { encodeEventTopics as b } from "./index135.js";
+import { numberToHex as m } from "./index108.js";
+import { createFilterRequestScope as h } from "./index206.js";
+async function l(r, { address: p, args: a, event: e, events: c, fromBlock: n, strict: f, toBlock: i } = {}) {
+  const o = c ?? (e ? [e] : void 0), u = h(r, {
+    method: "eth_newFilter"
+  });
+  let t = [];
+  o && (t = [o.flatMap((d) => b({
+    abi: [d],
+    eventName: d.name,
+    args: a
+  }))], e && (t = t[0]));
+  const s = await r.request({
+    method: "eth_newFilter",
+    params: [
+      {
+        address: p,
+        fromBlock: typeof n == "bigint" ? m(n) : n,
+        toBlock: typeof i == "bigint" ? m(i) : i,
+        ...t.length ? { topics: t } : {}
+      }
+    ]
+  });
+  return {
+    abi: o,
+    args: a,
+    eventName: e ? e.name : void 0,
+    fromBlock: n,
+    id: s,
+    request: u(s),
+    strict: !!f,
+    toBlock: i,
+    type: "event"
+  };
+}
+export {
+  l as createEventFilter
+};

package/dist/esm/index28.js

@@ -0,0 +1,12 @@
+import { createFilterRequestScope as r } from "./index206.js";
+async function a(e) {
+  const n = r(e, {
+    method: "eth_newPendingTransactionFilter"
+  }), t = await e.request({
+    method: "eth_newPendingTransactionFilter"
+  });
+  return { id: t, request: n(t), type: "transaction" };
+}
+export {
+  a as createPendingTransactionFilter
+};

package/dist/esm/index29.js

@@ -0,0 +1,32 @@
+import { parseAccount as u } from "./index10.js";
+import { encodeFunctionData as f } from "./index136.js";
+import { getContractError as p } from "./index179.js";
+import { getAction as g } from "./index205.js";
+import { estimateGas as G } from "./index31.js";
+async function A(s, i) {
+  const { abi: a, address: o, args: r, functionName: c, dataSuffix: e, ...t } = i, m = f({
+    abi: a,
+    args: r,
+    functionName: c
+  });
+  try {
+    return await g(s, G, "estimateGas")({
+      data: `${m}${e ? e.replace("0x", "") : ""}`,
+      to: o,
+      ...t
+    });
+  } catch (n) {
+    const d = t.account ? u(t.account) : void 0;
+    throw p(n, {
+      abi: a,
+      address: o,
+      args: r,
+      docsPath: "/docs/contract/estimateContractGas",
+      functionName: c,
+      sender: d?.address
+    });
+  }
+}
+export {
+  A as estimateContractGas
+};

package/dist/esm/index3.js

@@ -1,54 +1,83 @@
-import { signOut as c, signEvmHash as u, signEvmTransaction as p, sendEvmTransaction as d, signEvmMessage as m, signEvmTypedData as E, exportEvmAccount as g, signInWithEmail as v, verifyEmailOTP as S } from "@coinbase/cdp-core";
-import { useCallback as a } from "react";
-import { useCDP as t } from "./index2.js";
-const h = () => {
-  const { config: n } = t();
-  return n;
-}, I = () => {
-  const { isInitialized: n } = t();
-  return n;
-}, y = () => i(v), C = () => i(S), A = () => {
-  const { isSignedIn: n } = t();
-  return n;
-}, w = () => {
-  const { currentUser: n } = t();
-  return n;
-}, U = () => e(c), O = () => w()?.evmAccounts?.[0] ?? null, x = () => e(u), D = () => e(p), H = () => e(d), M = () => e(m), P = () => e(E), b = () => e(g), e = (n) => {
-  const { isSignedIn: r } = t();
-  return a(
-    async (...s) => {
-      if (!r)
+import { getAccessToken as w, signInWithEmail as v, signInWithSms as h, verifyEmailOTP as f, verifySmsOTP as T, signOut as y, signEvmHash as I, signEvmTransaction as O, sendEvmTransaction as P, signEvmMessage as A, signEvmTypedData as C, exportEvmAccount as W } from "@coinbase/cdp-core";
+import { useState as p, useEffect as k, useMemo as x, useCallback as d } from "react";
+import { useCDP as r } from "./index2.js";
+import { getPublicClient as U } from "./index4.js";
+const R = () => {
+  const { config: n } = r();
+  return { config: n };
+}, F = () => {
+  const { isInitialized: n } = r();
+  return { isInitialized: n };
+}, z = () => ({ signInWithEmail: c(v) }), G = () => ({ signInWithSms: c(h) }), j = () => ({ verifyEmailOTP: c(f) }), q = () => ({ verifySmsOTP: c(T) }), B = () => {
+  const { isSignedIn: n } = r();
+  return { isSignedIn: n };
+}, D = () => {
+  const { currentUser: n } = r();
+  return { currentUser: n };
+}, J = () => ({ signOut: s(y) }), K = () => ({ getAccessToken: w }), L = () => ({ evmAddress: D().currentUser?.evmAccounts?.[0] ?? null }), N = () => ({ signEvmHash: s(I) }), Q = () => ({ signEvmTransaction: s(O) }), X = () => {
+  const [n, t] = p(null), [a, i] = p(null), [o, m] = p(null), { config: g } = r(), E = s(
+    async (u) => {
+      const e = await P(u);
+      return t({ hash: e.transactionHash, network: u.network }), m(null), i(null), e;
+    }
+  );
+  k(() => {
+    if (!n) return;
+    (async () => {
+      try {
+        const l = await U(n.network, g).waitForTransactionReceipt({
+          hash: n.hash
+        });
+        i(l);
+      } catch (e) {
+        m(e instanceof Error ? e : new Error(String(e)));
+      }
+    })();
+  }, [n]);
+  const S = x(() => n ? a ? { status: "success", receipt: a } : o ? { status: "error", error: o } : { status: "pending", hash: n.hash } : { status: "idle" }, [n, a, o]);
+  return {
+    sendEvmTransaction: E,
+    data: S
+  };
+}, Y = () => ({ signEvmMessage: s(A) }), Z = () => ({ signEvmTypedData: s(C) }), _ = () => ({ exportEvmAccount: s(W) }), s = (n) => {
+  const { isSignedIn: t } = r();
+  return d(
+    async (...i) => {
+      if (!t)
         throw new Error("User is not authenticated");
-      return n(...s);
+      return n(...i);
     },
-    [r, n]
+    [t, n]
   );
-}, i = (n) => {
-  const { isSignedIn: r } = t();
-  return a(
-    async (...s) => {
-      if (r)
+}, c = (n) => {
+  const { isSignedIn: t } = r();
+  return d(
+    async (...i) => {
+      if (t)
         throw new Error("User is already authenticated. Please sign out first.");
-      return n(...s);
+      return n(...i);
     },
-    [r, n]
+    [t, n]
   );
 };
 export {
-  h as useConfig,
-  w as useCurrentUser,
-  e as useEnforceAuthenticated,
-  i as useEnforceUnauthenticated,
-  O as useEvmAddress,
-  b as useExportEvmAccount,
-  I as useIsInitialized,
-  A as useIsSignedIn,
-  H as useSendEvmTransaction,
-  x as useSignEvmHash,
-  M as useSignEvmMessage,
-  D as useSignEvmTransaction,
-  P as useSignEvmTypedData,
-  y as useSignInWithEmail,
-  U as useSignOut,
-  C as useVerifyEmailOTP
+  R as useConfig,
+  D as useCurrentUser,
+  s as useEnforceAuthenticated,
+  c as useEnforceUnauthenticated,
+  L as useEvmAddress,
+  _ as useExportEvmAccount,
+  K as useGetAccessToken,
+  F as useIsInitialized,
+  B as useIsSignedIn,
+  X as useSendEvmTransaction,
+  N as useSignEvmHash,
+  Y as useSignEvmMessage,
+  Q as useSignEvmTransaction,
+  Z as useSignEvmTypedData,
+  z as useSignInWithEmail,
+  G as useSignInWithSms,
+  J as useSignOut,
+  j as useVerifyEmailOTP,
+  q as useVerifySmsOTP
 };