@coinbase/cdp-hooks 0.0.17 → 0.0.19

package/dist/esm/index159.js

@@ -0,0 +1,40 @@
+import { versionedHashVersionKzg as a } from "./index158.js";
+import { BaseError as s } from "./index81.js";
+class t extends s {
+  constructor({ maxSize: e, size: r }) {
+    super("Blob size is too large.", {
+      metaMessages: [`Max: ${e} bytes`, `Given: ${r} bytes`],
+      name: "BlobSizeTooLargeError"
+    });
+  }
+}
+class d extends s {
+  constructor() {
+    super("Blob data must not be empty.", { name: "EmptyBlobError" });
+  }
+}
+class l extends s {
+  constructor({ hash: e, size: r }) {
+    super(`Versioned hash "${e}" size is invalid.`, {
+      metaMessages: ["Expected: 32", `Received: ${r}`],
+      name: "InvalidVersionedHashSizeError"
+    });
+  }
+}
+class c extends s {
+  constructor({ hash: e, version: r }) {
+    super(`Versioned hash "${e}" version is invalid.`, {
+      metaMessages: [
+        `Expected: ${a}`,
+        `Received: ${r}`
+      ],
+      name: "InvalidVersionedHashVersionError"
+    });
+  }
+}
+export {
+  t as BlobSizeTooLargeError,
+  d as EmptyBlobError,
+  l as InvalidVersionedHashSizeError,
+  c as InvalidVersionedHashVersionError
+};

package/dist/esm/index16.js

@@ -0,0 +1,22 @@
+import { buildRequest as m } from "./index70.js";
+import { uid as e } from "./index11.js";
+function b({ key: n, methods: i, name: t, request: o, retryCount: r = 3, retryDelay: u = 150, timeout: c, type: f }, p) {
+  const d = e();
+  return {
+    config: {
+      key: n,
+      methods: i,
+      name: t,
+      request: o,
+      retryCount: r,
+      retryDelay: u,
+      timeout: c,
+      type: f
+    },
+    request: m(o, { methods: i, retryCount: r, retryDelay: u, uid: d }),
+    value: p
+  };
+}
+export {
+  b as createTransport
+};

package/dist/esm/index160.js

@@ -0,0 +1,113 @@
+import { call as h } from "./index23.js";
+import { OffchainLookupSenderMismatchError as w, OffchainLookupError as b, OffchainLookupResponseMalformedError as k } from "./index161.js";
+import { HttpRequestError as m } from "./index12.js";
+import { decodeErrorResult as g } from "./index86.js";
+import { encodeAbiParameters as q } from "./index123.js";
+import { isAddressEqual as E } from "./index140.js";
+import { concat as L } from "./index112.js";
+import { isHex as O } from "./index144.js";
+import { localBatchGatewayUrl as R, localBatchGatewayRequest as x } from "./index162.js";
+import { stringify as S } from "./index102.js";
+const I = "0x556f1830", T = {
+  name: "OffchainLookup",
+  type: "error",
+  inputs: [
+    {
+      name: "sender",
+      type: "address"
+    },
+    {
+      name: "urls",
+      type: "string[]"
+    },
+    {
+      name: "callData",
+      type: "bytes"
+    },
+    {
+      name: "callbackFunction",
+      type: "bytes4"
+    },
+    {
+      name: "extraData",
+      type: "bytes"
+    }
+  ]
+};
+async function J(c, { blockNumber: i, blockTag: p, data: a, to: o }) {
+  const { args: n } = g({
+    data: a,
+    abi: [T]
+  }), [r, s, f, e, t] = n, { ccipRead: u } = c, d = u && typeof u?.request == "function" ? u.request : A;
+  try {
+    if (!E(o, r))
+      throw new w({ sender: r, to: o });
+    const l = s.includes(R) ? await x({
+      data: f,
+      ccipRequest: d
+    }) : await d({ data: f, sender: r, urls: s }), { data: y } = await h(c, {
+      blockNumber: i,
+      blockTag: p,
+      data: L([
+        e,
+        q([{ type: "bytes" }, { type: "bytes" }], [l, t])
+      ]),
+      to: o
+    });
+    return y;
+  } catch (l) {
+    throw new b({
+      callbackSelector: e,
+      cause: l,
+      data: a,
+      extraData: t,
+      sender: r,
+      urls: s
+    });
+  }
+}
+async function A({ data: c, sender: i, urls: p }) {
+  let a = new Error("An unknown error occurred.");
+  for (let o = 0; o < p.length; o++) {
+    const n = p[o], r = n.includes("{data}") ? "GET" : "POST", s = r === "POST" ? { data: c, sender: i } : void 0, f = r === "POST" ? { "Content-Type": "application/json" } : {};
+    try {
+      const e = await fetch(n.replace("{sender}", i.toLowerCase()).replace("{data}", c), {
+        body: JSON.stringify(s),
+        headers: f,
+        method: r
+      });
+      let t;
+      if (e.headers.get("Content-Type")?.startsWith("application/json") ? t = (await e.json()).data : t = await e.text(), !e.ok) {
+        a = new m({
+          body: s,
+          details: t?.error ? S(t.error) : e.statusText,
+          headers: e.headers,
+          status: e.status,
+          url: n
+        });
+        continue;
+      }
+      if (!O(t)) {
+        a = new k({
+          result: t,
+          url: n
+        });
+        continue;
+      }
+      return t;
+    } catch (e) {
+      a = new m({
+        body: s,
+        details: e.message,
+        url: n
+      });
+    }
+  }
+  throw a;
+}
+export {
+  A as ccipRequest,
+  J as offchainLookup,
+  T as offchainLookupAbiItem,
+  I as offchainLookupSignature
+};

package/dist/esm/index161.js

@@ -0,0 +1,51 @@
+import { stringify as m } from "./index102.js";
+import { BaseError as a } from "./index81.js";
+import { getUrl as t } from "./index93.js";
+class l extends a {
+  constructor({ callbackSelector: r, cause: e, data: n, extraData: f, sender: c, urls: o }) {
+    super(e.shortMessage || "An error occurred while fetching for an offchain result.", {
+      cause: e,
+      metaMessages: [
+        ...e.metaMessages || [],
+        e.metaMessages?.length ? "" : [],
+        "Offchain Gateway Call:",
+        o && [
+          "  Gateway URL(s):",
+          ...o.map((d) => `    ${t(d)}`)
+        ],
+        `  Sender: ${c}`,
+        `  Data: ${n}`,
+        `  Callback selector: ${r}`,
+        `  Extra data: ${f}`
+      ].flat(),
+      name: "OffchainLookupError"
+    });
+  }
+}
+class u extends a {
+  constructor({ result: r, url: e }) {
+    super("Offchain gateway response is malformed. Response data must be a hex value.", {
+      metaMessages: [
+        `Gateway URL: ${t(e)}`,
+        `Response: ${m(r)}`
+      ],
+      name: "OffchainLookupResponseMalformedError"
+    });
+  }
+}
+class g extends a {
+  constructor({ sender: r, to: e }) {
+    super("Reverted sender address does not match target contract address (`to`).", {
+      metaMessages: [
+        `Contract address: ${e}`,
+        `OffchainLookup sender address: ${r}`
+      ],
+      name: "OffchainLookupSenderMismatchError"
+    });
+  }
+}
+export {
+  l as OffchainLookupError,
+  u as OffchainLookupResponseMalformedError,
+  g as OffchainLookupSenderMismatchError
+};

package/dist/esm/index162.js

@@ -0,0 +1,35 @@
+import { batchGatewayAbi as o } from "./index71.js";
+import { solidityError as l } from "./index85.js";
+import { decodeFunctionData as f } from "./index128.js";
+import { encodeErrorResult as n } from "./index134.js";
+import { encodeFunctionResult as p } from "./index138.js";
+const d = "x-batch-gateway:true";
+async function g(t) {
+  const { data: i, ccipRequest: c } = t, { args: [u] } = f({ abi: o, data: i }), e = [], s = [];
+  return await Promise.all(u.map(async (r, a) => {
+    try {
+      s[a] = r.urls.includes(d) ? await g({ data: r.data, ccipRequest: c }) : await c(r), e[a] = !1;
+    } catch (m) {
+      e[a] = !0, s[a] = h(m);
+    }
+  })), p({
+    abi: o,
+    functionName: "query",
+    result: [e, s]
+  });
+}
+function h(t) {
+  return t.name === "HttpRequestError" && t.status ? n({
+    abi: o,
+    errorName: "HttpError",
+    args: [t.status, t.shortMessage]
+  }) : n({
+    abi: [l],
+    errorName: "Error",
+    args: ["shortMessage" in t ? t.shortMessage : t.message]
+  });
+}
+export {
+  g as localBatchGatewayRequest,
+  d as localBatchGatewayUrl
+};

package/dist/esm/index163.js

@@ -0,0 +1,11 @@
+import { hexToBytes as i } from "./index107.js";
+import { bytesToHex as f } from "./index108.js";
+function y(o) {
+  const { kzg: s } = o, n = o.to ?? (typeof o.blobs[0] == "string" ? "hex" : "bytes"), m = typeof o.blobs[0] == "string" ? o.blobs.map((t) => i(t)) : o.blobs, b = [];
+  for (const t of m)
+    b.push(Uint8Array.from(s.blobToKzgCommitment(t)));
+  return n === "bytes" ? b : b.map((t) => f(t));
+}
+export {
+  y as blobsToCommitments
+};

package/dist/esm/index164.js

@@ -0,0 +1,9 @@
+import { bytesToHex as i } from "./index108.js";
+import { sha256 as m } from "./index165.js";
+function f(t) {
+  const { commitment: e, version: s = 1 } = t, n = t.to ?? (typeof e == "string" ? "hex" : "bytes"), o = m(e);
+  return o.set([s], 0), n === "bytes" ? o : i(o);
+}
+export {
+  f as commitmentToVersionedHash
+};

package/dist/esm/index165.js

@@ -0,0 +1,9 @@
+import { sha256 as o } from "./index184.js";
+import { isHex as s } from "./index144.js";
+import { toBytes as r } from "./index107.js";
+function p(t, i) {
+  return o(s(t, { strict: !1 }) ? r(t) : t);
+}
+export {
+  p as sha256
+};

package/dist/esm/index166.js

@@ -0,0 +1,14 @@
+import { commitmentToVersionedHash as i } from "./index164.js";
+function r(o) {
+  const { commitments: t, version: n } = o, e = o.to ?? (typeof t[0] == "string" ? "hex" : "bytes"), s = [];
+  for (const m of t)
+    s.push(i({
+      commitment: m,
+      to: e,
+      version: n
+    }));
+  return s;
+}
+export {
+  r as commitmentsToVersionedHashes
+};

package/dist/esm/index167.js

@@ -0,0 +1,13 @@
+import { hexToBytes as b } from "./index107.js";
+import { bytesToHex as y } from "./index108.js";
+function h(t) {
+  const { kzg: m } = t, c = t.to ?? (typeof t.blobs[0] == "string" ? "hex" : "bytes"), s = typeof t.blobs[0] == "string" ? t.blobs.map((o) => b(o)) : t.blobs, i = typeof t.commitments[0] == "string" ? t.commitments.map((o) => b(o)) : t.commitments, n = [];
+  for (let o = 0; o < s.length; o++) {
+    const f = s[o], l = i[o];
+    n.push(Uint8Array.from(m.computeBlobKzgProof(f, l)));
+  }
+  return c === "bytes" ? n : n.map((o) => y(o));
+}
+export {
+  h as blobsToProofs
+};

package/dist/esm/index168.js

@@ -0,0 +1,16 @@
+import { blobsToCommitments as f } from "./index163.js";
+import { blobsToProofs as l } from "./index167.js";
+import { toBlobs as p } from "./index169.js";
+function k(t) {
+  const { data: i, kzg: n, to: m } = t, s = t.blobs ?? p({ data: i, to: m }), b = t.commitments ?? f({ blobs: s, kzg: n, to: m }), r = t.proofs ?? l({ blobs: s, commitments: b, kzg: n, to: m }), c = [];
+  for (let o = 0; o < s.length; o++)
+    c.push({
+      blob: s[o],
+      commitment: b[o],
+      proof: r[o]
+    });
+  return c;
+}
+export {
+  k as toBlobSidecars
+};

package/dist/esm/index169.js

@@ -0,0 +1,35 @@
+import { maxBytesPerTransaction as y, fieldElementsPerBlob as a, bytesPerFieldElement as f, bytesPerBlob as p } from "./index170.js";
+import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index159.js";
+import { createCursor as B } from "./index119.js";
+import { size as u } from "./index80.js";
+import { hexToBytes as x } from "./index107.js";
+import { bytesToHex as d } from "./index108.js";
+function S(e) {
+  const m = e.to ?? (typeof e.data == "string" ? "hex" : "bytes"), i = typeof e.data == "string" ? x(e.data) : e.data, o = u(i);
+  if (!o)
+    throw new c();
+  if (o > y)
+    throw new h({
+      maxSize: y,
+      size: o
+    });
+  const s = [];
+  let n = !0, r = 0;
+  for (; n; ) {
+    const t = B(new Uint8Array(p));
+    let l = 0;
+    for (; l < a; ) {
+      const b = i.slice(r, r + (f - 1));
+      if (t.pushByte(0), t.pushBytes(b), b.length < 31) {
+        t.pushByte(128), n = !1;
+        break;
+      }
+      l++, r += 31;
+    }
+    s.push(t);
+  }
+  return m === "bytes" ? s.map((t) => t.bytes) : s.map((t) => d(t.bytes));
+}
+export {
+  S as toBlobs
+};

package/dist/esm/index17.js

@@ -0,0 +1,113 @@
+import { getEnsAddress as a } from "./index18.js";
+import { getEnsAvatar as m } from "./index19.js";
+import { getEnsName as s } from "./index20.js";
+import { getEnsResolver as i } from "./index21.js";
+import { getEnsText as g } from "./index22.js";
+import { call as p } from "./index23.js";
+import { createAccessList as f } from "./index24.js";
+import { createBlockFilter as n } from "./index25.js";
+import { createContractEventFilter as c } from "./index26.js";
+import { createEventFilter as C } from "./index27.js";
+import { createPendingTransactionFilter as u } from "./index28.js";
+import { estimateContractGas as F } from "./index29.js";
+import { estimateFeesPerGas as T } from "./index30.js";
+import { estimateGas as E } from "./index31.js";
+import { estimateMaxPriorityFeePerGas as B } from "./index32.js";
+import { getBalance as v } from "./index33.js";
+import { getBlobBaseFee as d } from "./index34.js";
+import { getBlock as w } from "./index35.js";
+import { getBlockNumber as h } from "./index36.js";
+import { getBlockTransactionCount as k } from "./index37.js";
+import { getChainId as P } from "./index38.js";
+import { getCode as o } from "./index39.js";
+import { getContractEvents as y } from "./index40.js";
+import { getEip712Domain as G } from "./index41.js";
+import { getFeeHistory as R } from "./index42.js";
+import { getFilterChanges as A } from "./index43.js";
+import { getFilterLogs as b } from "./index44.js";
+import { getGasPrice as l } from "./index45.js";
+import { getLogs as L } from "./index46.js";
+import { getProof as M } from "./index47.js";
+import { getStorageAt as N } from "./index48.js";
+import { getTransaction as x } from "./index49.js";
+import { getTransactionConfirmations as D } from "./index50.js";
+import { getTransactionCount as S } from "./index51.js";
+import { getTransactionReceipt as q } from "./index52.js";
+import { multicall as H } from "./index53.js";
+import { readContract as I } from "./index54.js";
+import { simulateBlocks as e } from "./index55.js";
+import { simulateCalls as j } from "./index56.js";
+import { simulateContract as z } from "./index57.js";
+import { uninstallFilter as J } from "./index58.js";
+import { verifyMessage as K } from "./index59.js";
+import { verifyTypedData as O } from "./index60.js";
+import { waitForTransactionReceipt as Q } from "./index61.js";
+import { watchBlockNumber as U } from "./index62.js";
+import { watchBlocks as V } from "./index63.js";
+import { watchContractEvent as W } from "./index64.js";
+import { watchEvent as X } from "./index65.js";
+import { watchPendingTransactions as Y } from "./index66.js";
+import { verifySiweMessage as Z } from "./index67.js";
+import { prepareTransactionRequest as _ } from "./index68.js";
+import { sendRawTransaction as $ } from "./index69.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 {
+  _r as publicActions
+};

package/dist/esm/index170.js

@@ -0,0 +1,7 @@
+const e = 32, s = 4096, t = 131072, l = 761855;
+export {
+  t as bytesPerBlob,
+  e as bytesPerFieldElement,
+  s as fieldElementsPerBlob,
+  l as maxBytesPerTransaction
+};

package/dist/esm/index171.js

@@ -0,0 +1,11 @@
+function n(e) {
+  return {
+    formatters: void 0,
+    fees: void 0,
+    serializers: void 0,
+    ...e
+  };
+}
+export {
+  n as defineChain
+};

package/dist/esm/index172.js

@@ -0,0 +1,22 @@
+import { ChainDoesNotSupportContract as e } from "./index96.js";
+function a({ blockNumber: o, chain: r, contract: c }) {
+  const t = r?.contracts?.[c];
+  if (!t)
+    throw new e({
+      chain: r,
+      contract: { name: c }
+    });
+  if (o && t.blockCreated && t.blockCreated > o)
+    throw new e({
+      blockNumber: o,
+      chain: r,
+      contract: {
+        name: c,
+        blockCreated: t.blockCreated
+      }
+    });
+  return t.address;
+}
+export {
+  a as getChainContractAddress
+};

package/dist/esm/index173.js

@@ -0,0 +1,34 @@
+const i = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
+function p(o) {
+  const a = (s, t) => ({
+    clear: () => t.delete(s),
+    get: () => t.get(s),
+    set: (r) => t.set(s, r)
+  }), n = a(o, i), e = a(o, c);
+  return {
+    clear: () => {
+      n.clear(), e.clear();
+    },
+    promise: n,
+    response: e
+  };
+}
+async function l(o, { cacheKey: a, cacheTime: n = Number.POSITIVE_INFINITY }) {
+  const e = p(a), s = e.response.get();
+  if (s && n > 0 && (/* @__PURE__ */ new Date()).getTime() - s.created.getTime() < n)
+    return s.data;
+  let t = e.promise.get();
+  t || (t = o(), e.promise.set(t));
+  try {
+    const r = await t;
+    return e.response.set({ created: /* @__PURE__ */ new Date(), data: r }), r;
+  } finally {
+    e.promise.clear();
+  }
+}
+export {
+  p as getCache,
+  i as promiseCache,
+  c as responseCache,
+  l as withCache
+};

package/dist/esm/index174.js

@@ -0,0 +1,23 @@
+import { wait as w } from "./index175.js";
+function p(n, { delay: e = 100, retryCount: o = 2, shouldRetry: c = () => !0 } = {}) {
+  return new Promise((s, y) => {
+    const a = async ({ count: r = 0 } = {}) => {
+      const f = async ({ error: t }) => {
+        const i = typeof e == "function" ? e({ count: r, error: t }) : e;
+        i && await w(i), a({ count: r + 1 });
+      };
+      try {
+        const t = await n();
+        s(t);
+      } catch (t) {
+        if (r < o && await c({ count: r, error: t }))
+          return f({ error: t });
+        y(t);
+      }
+    };
+    a();
+  });
+}
+export {
+  p as withRetry
+};

package/dist/esm/index175.js

@@ -0,0 +1,6 @@
+async function n(e) {
+  return new Promise((t) => setTimeout(t, e));
+}
+export {
+  n as wait
+};

package/dist/esm/index176.js

@@ -0,0 +1,20 @@
+function u(n, { errorInstance: i = new Error("timed out"), timeout: t, signal: l }) {
+  return new Promise((a, o) => {
+    (async () => {
+      let e;
+      try {
+        const r = new AbortController();
+        t > 0 && (e = setTimeout(() => {
+          l && r.abort();
+        }, t)), a(await n({ signal: r?.signal || null }));
+      } catch (r) {
+        r?.name === "AbortError" && o(i), o(r);
+      } finally {
+        clearTimeout(e);
+      }
+    })();
+  });
+}
+export {
+  u as withTimeout
+};

package/dist/esm/index177.js

@@ -0,0 +1,13 @@
+function a(r, n) {
+  let t = r.toString();
+  const i = t.startsWith("-");
+  i && (t = t.slice(1)), t = t.padStart(n, "0");
+  let [l, e] = [
+    t.slice(0, t.length - n),
+    t.slice(t.length - n)
+  ];
+  return e = e.replace(/(0+)$/, ""), `${i ? "-" : ""}${l || "0"}${e ? `.${e}` : ""}`;
+}
+export {
+  a as formatUnits
+};

package/dist/esm/index178.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
+};