@coinbase/cdp-core 0.0.24 → 0.0.26

package/dist/esm/index.web60.js

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

package/dist/esm/index.web61.js

@@ -0,0 +1,5 @@
+import { sha256 as s } from "./index.web79.js";
+const o = s;
+export {
+  o as sha256
+};

package/dist/esm/{index53.js → index.web62.js}

@@ -1,4 +1,4 @@
-import { InvalidSerializableTransactionError as f } from "./index54.js";
+import { InvalidSerializableTransactionError as f } from "./index.web63.js";
 function d(e) {
   if (e.type)
     return e.type;

package/dist/esm/{index54.js → index.web63.js}

@@ -1,4 +1,4 @@
-import { BaseError as t } from "./index47.js";
+import { BaseError as t } from "./index.web56.js";
 function i(n) {
   const r = Object.entries(n).map(([a, e]) => e === void 0 || e === !1 ? null : [a, e]).filter(Boolean), o = r.reduce((a, [e]) => Math.max(a, e.length), 0);
   return r.map(([a, e]) => `  ${`${a}:`.padEnd(o + 1)}  ${e}`).join(`

package/dist/esm/{index55.js → index.web64.js}

@@ -1,14 +1,14 @@
-import { versionedHashVersionKzg as c } from "./index56.js";
-import { maxUint256 as m } from "./index57.js";
-import { InvalidAddressError as s } from "./index58.js";
-import { BaseError as h } from "./index47.js";
-import { EmptyBlobError as P, InvalidVersionedHashSizeError as p, InvalidVersionedHashVersionError as x } from "./index59.js";
-import { InvalidChainIdError as n } from "./index60.js";
-import { FeeCapTooHighError as w, TipAboveFeeCapError as E } from "./index61.js";
-import { isAddress as f } from "./index32.js";
-import { size as F } from "./index37.js";
-import { slice as I } from "./index38.js";
-import { hexToNumber as G } from "./index43.js";
+import { versionedHashVersionKzg as c } from "./index.web65.js";
+import { maxUint256 as m } from "./index.web66.js";
+import { InvalidAddressError as s } from "./index.web28.js";
+import { BaseError as h } from "./index.web56.js";
+import { EmptyBlobError as P, InvalidVersionedHashSizeError as p, InvalidVersionedHashVersionError as x } from "./index.web67.js";
+import { InvalidChainIdError as n } from "./index.web68.js";
+import { FeeCapTooHighError as w, TipAboveFeeCapError as E } from "./index.web69.js";
+import { isAddress as f } from "./index.web29.js";
+import { size as F } from "./index.web46.js";
+import { slice as I } from "./index.web47.js";
+import { hexToNumber as G } from "./index.web52.js";
 function C(t) {
   const { authorizationList: e } = t;
   if (e)

package/dist/esm/index.web65.js

@@ -0,0 +1,4 @@
+const e = 1;
+export {
+  e as versionedHashVersionKzg
+};

package/dist/esm/index.web66.js

@@ -0,0 +1,4 @@
+const n = 2n ** 256n - 1n;
+export {
+  n as maxUint256
+};

package/dist/esm/{index59.js → index.web67.js}

@@ -1,5 +1,5 @@
-import { versionedHashVersionKzg as a } from "./index56.js";
-import { BaseError as s } from "./index47.js";
+import { versionedHashVersionKzg as a } from "./index.web65.js";
+import { BaseError as s } from "./index.web56.js";
 class t extends s {
   constructor({ maxSize: e, size: r }) {
     super("Blob size is too large.", {

package/dist/esm/{index60.js → index.web68.js}

@@ -1,4 +1,4 @@
-import { BaseError as i } from "./index47.js";
+import { BaseError as i } from "./index.web56.js";
 class o extends i {
   constructor({ chainId: r }) {
     super(typeof r == "number" ? `Chain ID "${r}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });

package/dist/esm/{index61.js → index.web69.js}

@@ -1,5 +1,5 @@
-import { formatGwei as a } from "./index67.js";
-import { BaseError as o } from "./index47.js";
+import { formatGwei as a } from "./index.web75.js";
+import { BaseError as o } from "./index.web56.js";
 class n extends o {
   constructor({ cause: r, maxFeePerGas: e } = {}) {
     super(`The fee cap (\`maxFeePerGas\`${e ? ` = ${a(e)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {

package/dist/esm/index.web7.js

@@ -0,0 +1,121 @@
+import { Provider as h } from "ox";
+import { http as m } from "viem";
+import { create as p } from "zustand";
+import { subscribeWithSelector as g, persist as f } from "./index.web21.js";
+import { validateRequest as I, EIP1193ProviderError as S, STANDARD_ERROR_CODES as w } from "./index.web8.js";
+import { EventEmitter as C } from "./index.web22.js";
+import { getPlatformStorage as b } from "./index.web2.js";
+import "@coinbase/cdp-api-client";
+import { handleGetCapabilities as _, handleGetCallsStatus as A, handleSendCalls as v, handleChainId as D, handleSignTypedData as P, handleEthSign as E, handleSwitchEthereumChain as R, handleDisconnect as y, handleSendTransaction as T, handlePersonalSign as q, handleRequestAccounts as G, handleAccounts as L } from "./index.web23.js";
+import { onAuthStateChange as M } from "./index.web5.js";
+import { baseSepolia as l } from "./index.web24.js";
+function N(r, n, s) {
+  n.subscribe(
+    (e) => e.chainId,
+    (e, t) => {
+      e !== t && r.emit("chainChanged", e);
+    }
+  ), n.subscribe(
+    (e) => e.user,
+    (e, t) => {
+      if (!(e?.userId === t?.userId && e?.evmAccounts?.length === t?.evmAccounts?.length)) {
+        if (!e && t) {
+          r.emit("disconnect", new h.DisconnectedError());
+          return;
+        }
+        if (e && e.evmAccounts?.length && (!t || t.evmAccounts?.length === 0)) {
+          const a = n.getState().chainId;
+          r.emit("connect", { chainId: a });
+          return;
+        }
+      }
+    }
+  );
+  const { chainId: i, setChainId: o } = n.getState(), d = i || s.chains[0].id;
+  return i || o(d), h.from({
+    request: async (e) => {
+      I(e, s);
+      const t = e;
+      switch (t.method) {
+        case "eth_accounts":
+          return L();
+        case "eth_requestAccounts":
+          return G(r, n);
+        case "personal_sign":
+          return q(t.params);
+        case "eth_sendTransaction":
+          return T(t.params, n, s.transports);
+        case "wallet_disconnect":
+          return y();
+        case "wallet_switchEthereumChain":
+          return R(t.params, n);
+        case "eth_sign":
+          return E(t.params);
+        case "eth_signTypedData_v4":
+          return P(t.params);
+        case "eth_chainId":
+          return D(n);
+        case "wallet_sendCalls":
+          return v(t.params, n);
+        case "wallet_getCallsStatus":
+          return A(t.params, n);
+        case "wallet_getCapabilities":
+          return _();
+        // Catch-all for any unknown method
+        default:
+          throw new S(
+            w.provider.unsupportedMethod,
+            `Method ${t.method} not supported`
+          );
+      }
+    },
+    // Event emitter methods - only the ones required by the interface
+    on: r.on.bind(r),
+    removeListener: r.removeListener.bind(r)
+  });
+}
+const u = {
+  chains: [l],
+  transports: {
+    [l.id]: m()
+  }
+};
+function K(r) {
+  if (r?.chains.length === 0)
+    throw new Error("At least one chain must be configured");
+  const n = r?.chains ?? u.chains, s = r?.transports ?? u.transports;
+  if (n.length === 0)
+    throw new Error("No chains found in configuration");
+  const i = new C(), o = b(), d = {
+    getItem: (t) => o.getItem(t),
+    setItem: (t, a) => o.setItem(t, a),
+    removeItem: (t) => o.removeItem(t)
+  }, c = p()(
+    g(
+      f(
+        (t) => ({
+          chainId: n[0].id,
+          setChainId: (a) => t({ chainId: a }),
+          chains: n,
+          user: null,
+          setUser: (a) => t({ user: a })
+        }),
+        {
+          name: "cdp-provider-store",
+          storage: d
+        }
+      )
+    )
+  );
+  return c.persist.rehydrate(), M((t) => {
+    c.getState().setUser(t);
+  }), {
+    provider: N(i, c, {
+      chains: n,
+      transports: s
+    })
+  };
+}
+export {
+  K as createCDPEmbeddedWallet
+};

package/dist/esm/{index62.js → index.web70.js}

@@ -1,5 +1,5 @@
-import { hexToBytes as i } from "./index29.js";
-import { bytesToHex as f } from "./index27.js";
+import { hexToBytes as i } from "./index.web39.js";
+import { bytesToHex as f } from "./index.web37.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)

package/dist/esm/{index63.js → index.web71.js}

@@ -1,5 +1,5 @@
-import { hexToBytes as b } from "./index29.js";
-import { bytesToHex as y } from "./index27.js";
+import { hexToBytes as b } from "./index.web39.js";
+import { bytesToHex as y } from "./index.web37.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++) {

package/dist/esm/{index64.js → index.web72.js}

@@ -1,4 +1,4 @@
-import { commitmentToVersionedHash as i } from "./index79.js";
+import { commitmentToVersionedHash as i } from "./index.web92.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)

package/dist/esm/{index65.js → index.web73.js}

@@ -1,6 +1,6 @@
-import { blobsToCommitments as f } from "./index62.js";
-import { blobsToProofs as l } from "./index63.js";
-import { toBlobs as p } from "./index78.js";
+import { blobsToCommitments as f } from "./index.web70.js";
+import { blobsToProofs as l } from "./index.web71.js";
+import { toBlobs as p } from "./index.web91.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++)

package/dist/esm/{index66.js → index.web74.js}

@@ -1,6 +1,6 @@
-import { InvalidAddressError as s } from "./index58.js";
-import { InvalidStorageKeySizeError as l } from "./index54.js";
-import { isAddress as f } from "./index32.js";
+import { InvalidAddressError as s } from "./index.web28.js";
+import { InvalidStorageKeySizeError as l } from "./index.web63.js";
+import { isAddress as f } from "./index.web29.js";
 function a(r) {
   if (!r || r.length === 0)
     return [];

package/dist/esm/index.web75.js

@@ -0,0 +1,8 @@
+import { gweiUnits as i } from "./index.web76.js";
+import { formatUnits as o } from "./index.web77.js";
+function f(r, t = "wei") {
+  return o(r, i[t]);
+}
+export {
+  f as formatGwei
+};

package/dist/esm/index.web76.js

@@ -0,0 +1,7 @@
+const e = {
+  ether: -9,
+  wei: 9
+};
+export {
+  e as gweiUnits
+};

package/dist/esm/index.web77.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/index.web78.js

@@ -0,0 +1,12 @@
+import { contracts as o } from "./index.web93.js";
+import { formatters as r } from "./index.web94.js";
+import { serializers as t } from "./index.web95.js";
+const e = {
+  blockTime: 2e3,
+  contracts: o,
+  formatters: r,
+  serializers: t
+};
+export {
+  e as chainConfig
+};

package/dist/esm/{index77.js → index.web79.js}

@@ -1,5 +1,5 @@
-import { HashMD as D, SHA256_IV as b, Chi as g, Maj as p } from "./index86.js";
-import { createHasher as u, clean as C, rotr as i } from "./index76.js";
+import { HashMD as D, SHA256_IV as b, Chi as g, Maj as p } from "./index.web80.js";
+import { createHasher as u, clean as C, rotr as i } from "./index.web81.js";
 const B = /* @__PURE__ */ Uint32Array.from([
   1116352408,
   1899447441,

package/dist/esm/{index4.js → index.web8.js}

@@ -2,8 +2,8 @@ import "ox";
 import "viem";
 import "zustand";
 import "@coinbase/cdp-api-client";
-import { getCurrentUser as u } from "./index2.js";
-import "./index3.js";
+import { getCurrentUser as u } from "./index.web5.js";
+import "./index.web7.js";
 const r = {
   rpc: {
     invalidInput: -32e3,

package/dist/esm/{index86.js → index.web80.js}

@@ -1,4 +1,4 @@
-import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index76.js";
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.web81.js";
 function y(o, t, s, n) {
   if (typeof o.setBigUint64 == "function")
     return o.setBigUint64(t, s, n);

package/dist/esm/index.web81.js

@@ -0,0 +1,82 @@
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function o(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function w(e) {
+  if (!Number.isSafeInteger(e) || e < 0)
+    throw new Error("positive integer expected, got " + e);
+}
+function r(e, ...t) {
+  if (!o(e))
+    throw new Error("Uint8Array expected");
+  if (t.length > 0 && !t.includes(e.length))
+    throw new Error("Uint8Array expected of length " + t + ", got length=" + e.length);
+}
+function h(e, t = !0) {
+  if (e.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (t && e.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function l(e, t) {
+  r(e);
+  const n = t.outputLen;
+  if (e.length < n)
+    throw new Error("digestInto() expects output buffer of length at least " + n);
+}
+function a(e) {
+  return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+}
+function g(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+function p(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function b(e, t) {
+  return e << 32 - t | e >>> t;
+}
+const i = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function u(e) {
+  return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
+}
+function c(e) {
+  for (let t = 0; t < e.length; t++)
+    e[t] = u(e[t]);
+  return e;
+}
+const x = i ? (e) => e : c;
+function s(e) {
+  if (typeof e != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function y(e) {
+  return typeof e == "string" && (e = s(e)), r(e), e;
+}
+class d {
+}
+function E(e) {
+  const t = (f) => e().update(y(f)).digest(), n = e();
+  return t.outputLen = n.outputLen, t.blockLen = n.blockLen, t.create = () => e(), t;
+}
+export {
+  d as Hash,
+  r as abytes,
+  h as aexists,
+  w as anumber,
+  l as aoutput,
+  u as byteSwap,
+  c as byteSwap32,
+  g as clean,
+  E as createHasher,
+  p as createView,
+  o as isBytes,
+  i as isLE,
+  b as rotr,
+  x as swap32IfBE,
+  y as toBytes,
+  a as u32,
+  s as utf8ToBytes
+};

package/dist/esm/{index88.js → index.web82.js}

@@ -1,5 +1,5 @@
-import { encoder as t, decoder as o } from "./index81.js";
-import { encodeBase64 as c, decodeBase64 as a } from "./index97.js";
+import { encoder as t, decoder as o } from "./index.web31.js";
+import { encodeBase64 as c, decodeBase64 as a } from "./index.web96.js";
 function i(r) {
   if (Uint8Array.fromBase64)
     return Uint8Array.fromBase64(typeof r == "string" ? r : o.decode(r), {

package/dist/esm/{index89.js → index.web83.js}

@@ -1,6 +1,6 @@
-import n from "./index98.js";
-import s from "./index99.js";
-import a from "./index100.js";
+import n from "./index.web97.js";
+import s from "./index.web98.js";
+import a from "./index.web99.js";
 const y = async (t, o, e) => {
   const r = await a(t, o, "sign");
   s(t, r);

package/dist/esm/index.web84.js

@@ -0,0 +1,22 @@
+const a = (...o) => {
+  const t = o.filter(Boolean);
+  if (t.length === 0 || t.length === 1)
+    return !0;
+  let e;
+  for (const s of t) {
+    const r = Object.keys(s);
+    if (!e || e.size === 0) {
+      e = new Set(r);
+      continue;
+    }
+    for (const n of r) {
+      if (e.has(n))
+        return !1;
+      e.add(n);
+    }
+  }
+  return !0;
+};
+export {
+  a as default
+};

package/dist/esm/{index91.js → index.web85.js}

@@ -1,6 +1,6 @@
-import { withAlg as n } from "./index101.js";
-import c from "./index102.js";
-import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index103.js";
+import { withAlg as n } from "./index.web100.js";
+import c from "./index.web101.js";
+import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.web102.js";
 const s = (r) => r?.[Symbol.toStringTag], o = (r, e, t) => {
   if (e.use !== void 0) {
     let i;

package/dist/esm/{index92.js → index.web86.js}

@@ -1,4 +1,4 @@
-import { JOSENotSupported as f } from "./index71.js";
+import { JOSENotSupported as f } from "./index.web26.js";
 const w = (n, r, a, e, s) => {
   if (s.crit !== void 0 && e?.crit === void 0)
     throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');

package/dist/esm/{index93.js → index.web87.js}

@@ -1,7 +1,7 @@
-import { isJWK as p } from "./index103.js";
-import { decode as m } from "./index88.js";
-import y from "./index104.js";
-import { isCryptoKey as S, isKeyObject as K } from "./index102.js";
+import { isJWK as p } from "./index.web102.js";
+import { decode as m } from "./index.web82.js";
+import y from "./index.web103.js";
+import { isCryptoKey as S, isKeyObject as K } from "./index.web101.js";
 let c;
 const f = async (e, r, s, i = !1) => {
   c ||= /* @__PURE__ */ new WeakMap();

package/dist/esm/index.web88.js

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

package/dist/esm/{index74.js → index.web89.js}

@@ -1,4 +1,4 @@
-import { BaseError as o } from "./index47.js";
+import { BaseError as o } from "./index.web56.js";
 class i extends o {
   constructor({ offset: e }) {
     super(`Offset \`${e}\` cannot be negative.`, {

package/dist/esm/{index5.js → index.web9.js}

@@ -1,7 +1,7 @@
 import { getTypesForEIP712Domain as a } from "viem";
-import { getCurrentUser as s, signEvmHash as i, signEvmTypedData as c, signEvmTransaction as u, signEvmMessage as m } from "./index2.js";
+import { getCurrentUser as s, signEvmHash as i, signEvmTypedData as c, signEvmTransaction as u, signEvmMessage as m } from "./index.web5.js";
 import "@coinbase/cdp-api-client";
-import { toAccount as g } from "./index16.js";
+import { toAccount as g } from "./index.web20.js";
 async function w(r) {
   const n = await s();
   if (!n || !n.evmAccounts || n.evmAccounts.length === 0)

package/dist/esm/index.web90.js

@@ -0,0 +1,22 @@
+const o = /* @__PURE__ */ BigInt(4294967295), i = /* @__PURE__ */ BigInt(32);
+function s(t, r = !1) {
+  return r ? { h: Number(t & o), l: Number(t >> i & o) } : { h: Number(t >> i & o) | 0, l: Number(t & o) | 0 };
+}
+function h(t, r = !1) {
+  const n = t.length;
+  let l = new Uint32Array(n), c = new Uint32Array(n);
+  for (let e = 0; e < n; e++) {
+    const { h: u, l: f } = s(t[e], r);
+    [l[e], c[e]] = [u, f];
+  }
+  return [l, c];
+}
+const m = (t, r, n) => t << n | r >>> 32 - n, A = (t, r, n) => r << n | t >>> 32 - n, B = (t, r, n) => r << n - 32 | t >>> 64 - n, a = (t, r, n) => t << n - 32 | r >>> 64 - n;
+export {
+  s as fromBig,
+  B as rotlBH,
+  a as rotlBL,
+  m as rotlSH,
+  A as rotlSL,
+  h as split
+};

package/dist/esm/{index78.js → index.web91.js}

@@ -1,9 +1,9 @@
-import { maxBytesPerTransaction as y, bytesPerBlob as a, fieldElementsPerBlob as f, bytesPerFieldElement as p } from "./index87.js";
-import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index59.js";
-import { createCursor as B } from "./index48.js";
-import { size as u } from "./index37.js";
-import { hexToBytes as x } from "./index29.js";
-import { bytesToHex as d } from "./index27.js";
+import { maxBytesPerTransaction as y, bytesPerBlob as a, fieldElementsPerBlob as f, bytesPerFieldElement as p } from "./index.web104.js";
+import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index.web67.js";
+import { createCursor as B } from "./index.web57.js";
+import { size as u } from "./index.web46.js";
+import { hexToBytes as x } from "./index.web39.js";
+import { bytesToHex as d } from "./index.web37.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)

package/dist/esm/{index79.js → index.web92.js}

@@ -1,5 +1,5 @@
-import { bytesToHex as i } from "./index27.js";
-import { sha256 as m } from "./index51.js";
+import { bytesToHex as i } from "./index.web37.js";
+import { sha256 as m } from "./index.web60.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);

package/dist/esm/index.web93.js

@@ -0,0 +1,15 @@
+const s = {
+  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+  l1Block: { address: "0x4200000000000000000000000000000000000015" },
+  l2CrossDomainMessenger: {
+    address: "0x4200000000000000000000000000000000000007"
+  },
+  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+  l2ToL1MessagePasser: {
+    address: "0x4200000000000000000000000000000000000016"
+  }
+};
+export {
+  s as contracts
+};

package/dist/esm/{index95.js → index.web94.js}

@@ -1,7 +1,7 @@
-import { hexToBigInt as n } from "./index43.js";
-import { defineBlock as r } from "./index40.js";
-import { defineTransaction as s, formatTransaction as m } from "./index42.js";
-import { defineTransactionReceipt as l } from "./index45.js";
+import { hexToBigInt as n } from "./index.web52.js";
+import { defineBlock as r } from "./index.web49.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.web51.js";
+import { defineTransactionReceipt as l } from "./index.web54.js";
 const p = {
   block: /* @__PURE__ */ r({
     format(e) {

package/dist/esm/{index96.js → index.web95.js}

@@ -1,9 +1,9 @@
-import { InvalidAddressError as a } from "./index58.js";
-import { isAddress as f } from "./index32.js";
-import { concatHex as p } from "./index33.js";
-import { toHex as i } from "./index27.js";
-import { toRlp as x } from "./index46.js";
-import { serializeTransaction as l } from "./index15.js";
+import { InvalidAddressError as a } from "./index.web28.js";
+import { isAddress as f } from "./index.web29.js";
+import { concatHex as p } from "./index.web42.js";
+import { toHex as i } from "./index.web37.js";
+import { toRlp as x } from "./index.web55.js";
+import { serializeTransaction as l } from "./index.web18.js";
 function T(r, e) {
   return h(r) ? z(r) : l(r, e);
 }

package/dist/esm/index.web96.js

@@ -0,0 +1,20 @@
+function o(t) {
+  if (Uint8Array.prototype.toBase64)
+    return t.toBase64();
+  const e = 32768, n = [];
+  for (let r = 0; r < t.length; r += e)
+    n.push(String.fromCharCode.apply(null, t.subarray(r, r + e)));
+  return btoa(n.join(""));
+}
+function a(t) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(t);
+  const e = atob(t), n = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    n[r] = e.charCodeAt(r);
+  return n;
+}
+export {
+  a as decodeBase64,
+  o as encodeBase64
+};