@coinbase/cdp-core 0.0.25 → 0.0.27

package/dist/esm/{index2.js → index.web5.js}

@@ -1,51 +1,50 @@
-import { configureCdpApiClient as A, setAuthManager as v, initiateAuthentication as S, createEndUserEvmAccount as E, createEndUserEvmSmartAccount as g, verifyEmailAuthentication as k, verifySmsAuthentication as U, signEvmHashWithEndUserAccount as M, signEvmTransactionWithEndUserAccount as T, sendEvmTransactionWithEndUserAccount as j, signEvmMessageWithEndUserAccount as O, signEvmTypedDataWithEndUserAccount as P, sendUserOperationWithEndUserAccount as C, getUserOperationWithEndUserAccount as x, exportEndUserEvmAccount as H } from "@coinbase/cdp-api-client";
-import { AuthManager as W } from "./index7.js";
-import { toAuthState as m } from "./index8.js";
-import { withAuth as o } from "./index9.js";
-import { createExportKeyPair as b } from "./index10.js";
-import { decryptWithPrivateKey as K } from "./index11.js";
-import { MockAuthManager as D } from "./index12.js";
-import { mockUser as p } from "./index13.js";
-import { isChainSupportedForCDPSends as z } from "./index14.js";
-import { getConfig as t, setCoreAuthManager as h, getCoreAuthManager as s, setConfig as N } from "./index15.js";
+import { configureCdpApiClient as A, setAuthManager as v, initiateAuthentication as S, createEndUserEvmAccount as E, createEndUserEvmSmartAccount as p, verifyEmailAuthentication as k, verifySmsAuthentication as U, signEvmHashWithEndUserAccount as M, signEvmTransactionWithEndUserAccount as T, sendEvmTransactionWithEndUserAccount as P, signEvmMessageWithEndUserAccount as j, signEvmTypedDataWithEndUserAccount as C, sendUserOperationWithEndUserAccount as O, getUserOperationWithEndUserAccount as x, exportEndUserEvmAccount as H } from "@coinbase/cdp-api-client";
+import { AuthManager as W } from "./index.web6.js";
+import { toAuthState as m } from "./index.web12.js";
+import { withAuth as o } from "./index.web13.js";
+import { MockAuthManager as b } from "./index.web14.js";
+import { mockUser as h } from "./index.web15.js";
+import { getPlatformCrypto as K } from "./index.web2.js";
+import { isChainSupportedForCDPSends as D } from "./index.web16.js";
+import { getConfig as t, setCoreAuthManager as w, getCoreAuthManager as s, setConfig as z } from "./index.web17.js";
 import "viem";
-import { serializeTransaction as w } from "./index16.js";
-const _ = async (e) => {
+import { serializeTransaction as y } from "./index.web18.js";
+const Y = async (e) => {
   if (!e.projectId)
     throw new Error("Project ID is required");
-  let r;
+  let n;
   try {
-    r = t().projectId !== e.projectId;
+    n = t().projectId !== e.projectId;
   } catch {
-    r = !0;
+    n = !0;
   }
-  if (N(e), t().useMock) {
-    h(new D(t().projectId));
+  if (z(e), t().useMock) {
+    w(new b(t().projectId));
     return;
   }
   if (A({
     debugging: t().debugging,
     basePath: t().basePath
-  }), r) {
-    const n = new W(t().projectId);
-    h(n), v(n);
+  }), n) {
+    const r = new W(t().projectId);
+    w(r), v(r);
   }
   await s().ensureInitialized();
-}, ee = async (e) => y({
+}, Z = async (e) => l({
   email: e.email,
   type: "email"
-}), te = async (e) => y({
+}), _ = async (e) => l({
   phoneNumber: e.phoneNumber,
   type: "sms"
-}), re = async (e) => l(
+}), ee = async (e) => f(
   e,
   "Mock email OTP verified",
-  (r, n) => k(r, n)
-), ne = async (e) => l(
+  (n, r) => k(n, r)
+), te = async (e) => f(
   e,
   "Mock SMS OTP verified",
-  (r, n) => U(r, n)
-), se = async () => s().getUser(), ae = async () => s().isSignedIn(), ce = async () => {
+  (n, r) => U(n, r)
+), re = async () => s().getUser(), ne = async () => s().isSignedIn(), se = async () => {
   if (t().useMock) {
     await s().signOut();
     return;
@@ -53,63 +52,63 @@ const _ = async (e) => {
   if (!await s().isSignedIn())
     throw new Error("User not signed in");
   await s().signOut();
-}, ie = async () => s().getToken(), oe = (e) => {
+}, ae = async () => s().getToken(), ce = (e) => {
   s().addAuthStateChangeCallback(e);
-}, ue = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
-  signature: (await M(t().projectId, r.userId, {
+}, ie = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: n, walletSecretId: r }) => ({
+  signature: (await M(t().projectId, n.userId, {
     hash: e.hash,
     address: e.evmAccount,
-    walletSecretId: n
+    walletSecretId: r
   })).signature
-})), de = async (e) => t().useMock ? { signedTransaction: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => {
-  const i = w(e.transaction);
+})), oe = async (e) => t().useMock ? { signedTransaction: "0x0" } : o(e, s(), async ({ user: n, walletSecretId: r }) => {
+  const i = y(e.transaction);
   return {
     signedTransaction: (await T(
       t().projectId,
-      r.userId,
+      n.userId,
       {
         transaction: i,
         address: e.evmAccount,
-        walletSecretId: n
+        walletSecretId: r
       }
     )).signedTransaction
   };
-}), me = async (e) => {
-  if (!z(e.network))
+}), ue = async (e) => {
+  if (!D(e.network))
     throw new Error(`Chain ${e.network} is not supported by the CDP Apis`);
   if (t().useMock)
     return { transactionHash: "0x0" };
-  const r = w(e.transaction);
-  return o(e, s(), async ({ user: n, walletSecretId: i }) => ({
-    transactionHash: (await j(
+  const n = y(e.transaction);
+  return o(e, s(), async ({ user: r, walletSecretId: i }) => ({
+    transactionHash: (await P(
       t().projectId,
-      n.userId,
+      r.userId,
       {
-        transaction: r,
+        transaction: n,
         address: e.evmAccount,
         walletSecretId: i,
         network: e.network
       }
     )).transactionHash
   }));
-}, ge = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
-  signature: (await O(t().projectId, r.userId, {
+}, de = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: n, walletSecretId: r }) => ({
+  signature: (await j(t().projectId, n.userId, {
     message: e.message,
     address: e.evmAccount,
-    walletSecretId: n
+    walletSecretId: r
   })).signature
-})), pe = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
-  signature: (await P(t().projectId, r.userId, {
+})), me = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: n, walletSecretId: r }) => ({
+  signature: (await C(t().projectId, n.userId, {
     typedData: e.typedData,
     address: e.evmAccount,
-    walletSecretId: n
+    walletSecretId: r
   })).signature
-})), he = async (e) => t().useMock ? {
+})), ge = async (e) => t().useMock ? {
   userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
-} : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
-  userOperationHash: (await C(
+} : o(e, s(), async ({ user: n, walletSecretId: r }) => ({
+  userOperationHash: (await O(
     t().projectId,
-    r.userId,
+    n.userId,
     e.evmSmartAccount,
     {
       network: e.network,
@@ -118,12 +117,12 @@ const _ = async (e) => {
         value: String(a.value ?? 0n),
         data: a.data ?? "0x"
       })),
-      walletSecretId: n,
+      walletSecretId: r,
       useCdpPaymaster: e.useCdpPaymaster ?? !1,
       paymasterUrl: e.paymasterUrl
     }
   )).userOpHash
-})), we = async (e) => t().useMock ? {
+})), pe = async (e) => t().useMock ? {
   userOpHash: e.userOperationHash,
   network: e.network,
   calls: [
@@ -136,31 +135,31 @@ const _ = async (e) => {
   status: "complete",
   transactionHash: "0x9876543210987654321098765432109876543210987654321098765432109876",
   receipts: []
-} : o(e, s(), async ({ user: r }) => await x(
+} : o(e, s(), async ({ user: n }) => await x(
   t().projectId,
-  r.userId,
+  n.userId,
   e.evmSmartAccount,
   e.userOperationHash
-)), ye = async (e) => {
+)), he = async (e) => {
   if (t().useMock)
     return {
       privateKey: "mock-private-key"
     };
-  const r = await b();
-  return o(e, s(), async ({ user: n, walletSecretId: i }) => {
-    const a = await H(t().projectId, n.userId, {
+  const n = K(), r = await n.createExportKeyPair();
+  return o(e, s(), async ({ user: i, walletSecretId: a }) => {
+    const c = await H(t().projectId, i.userId, {
       address: e.evmAccount,
-      walletSecretId: i,
+      walletSecretId: a,
       exportEncryptionKey: r.publicKeyBase64
     });
     return {
-      privateKey: await K(
+      privateKey: await n.decryptWithPrivateKey(
         r.privateKey,
-        a.encryptedPrivateKey
+        c.encryptedPrivateKey
       )
     };
   });
-}, y = async (e) => {
+}, l = async (e) => {
   if (t().useMock)
     return {
       message: "Mock sign in initiated",
@@ -168,25 +167,25 @@ const _ = async (e) => {
     };
   if (await s().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const n = await S(t().projectId, e);
+  const r = await S(t().projectId, e);
   return {
-    flowId: n.flowId,
-    message: n.message
+    flowId: r.flowId,
+    message: r.message
   };
-}, l = async (e, r, n) => {
+}, f = async (e, n, r) => {
   if (t().useMock)
     return await s().setAuthState({
       accessToken: "mock-access-token",
       expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
-      user: p
+      user: h
     }), {
-      message: r,
-      user: p,
+      message: n,
+      user: h,
       isNewUser: !1
     };
   if (await s().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const a = await n(t().projectId, {
+  const a = await r(t().projectId, {
     flowId: e.flowId,
     otp: e.otp
   });
@@ -199,7 +198,7 @@ const _ = async (e) => {
       });
       if (t().createAccountOnLogin === "evm-smart") {
         const [I] = d.evmAccounts;
-        d = await g(
+        d = await p(
           t().projectId,
           c.user.userId,
           {
@@ -215,7 +214,7 @@ const _ = async (e) => {
     }
   if (t().createAccountOnLogin === "evm-smart" && (!c.user.evmSmartAccounts || c.user.evmSmartAccounts.length === 0))
     try {
-      const [u] = c.user.evmAccounts, d = await g(
+      const [u] = c.user.evmAccounts, d = await p(
         t().projectId,
         c.user.userId,
         {
@@ -228,30 +227,30 @@ const _ = async (e) => {
     } catch (u) {
       throw new Error(`Failed to create EVM Smart Account: ${u}`);
     }
-  const f = await s().getUser();
+  const g = await s().getUser();
   return {
     message: a.message,
-    user: f,
+    user: g,
     isNewUser: a.isNewEndUser
   };
 };
 export {
-  ye as exportEvmAccount,
-  ie as getAccessToken,
-  se as getCurrentUser,
-  we as getUserOperation,
-  _ as initialize,
-  ae as isSignedIn,
-  oe as onAuthStateChange,
-  me as sendEvmTransaction,
-  he as sendUserOperation,
-  ue as signEvmHash,
-  ge as signEvmMessage,
-  de as signEvmTransaction,
-  pe as signEvmTypedData,
-  ee as signInWithEmail,
-  te as signInWithSms,
-  ce as signOut,
-  re as verifyEmailOTP,
-  ne as verifySmsOTP
+  he as exportEvmAccount,
+  ae as getAccessToken,
+  re as getCurrentUser,
+  pe as getUserOperation,
+  Y as initialize,
+  ne as isSignedIn,
+  ce as onAuthStateChange,
+  ue as sendEvmTransaction,
+  ge as sendUserOperation,
+  ie as signEvmHash,
+  de as signEvmMessage,
+  oe as signEvmTransaction,
+  me as signEvmTypedData,
+  Z as signInWithEmail,
+  _ as signInWithSms,
+  se as signOut,
+  ee as verifyEmailOTP,
+  te as verifySmsOTP
 };

package/dist/esm/{index47.js → index.web50.js}

@@ -1,7 +1,7 @@
-import { BaseError as l } from "./index48.js";
-import { createCursor as r } from "./index49.js";
-import { hexToBytes as g } from "./index30.js";
-import { bytesToHex as u } from "./index28.js";
+import { BaseError as l } from "./index.web51.js";
+import { createCursor as r } from "./index.web52.js";
+import { hexToBytes as g } from "./index.web33.js";
+import { bytesToHex as u } from "./index.web31.js";
 function m(n, e = "hex") {
   const i = s(n), h = r(new Uint8Array(i.length));
   return i.encode(h), e === "hex" ? u(h.bytes) : h.bytes;

package/dist/esm/{index48.js → index.web51.js}

@@ -1,4 +1,4 @@
-import { version as o } from "./index75.js";
+import { version as o } from "./index.web79.js";
 let r = {
   getDocsUrl: ({ docsBaseUrl: s, docsPath: t = "", docsSlug: e }) => t ? `${s ?? "https://viem.sh"}${t}${e ? `#${e}` : ""}` : void 0,
   version: `viem@${o}`

package/dist/esm/{index49.js → index.web52.js}

@@ -1,4 +1,4 @@
-import { NegativeOffsetError as o, PositionOutOfBoundsError as e, RecursiveReadLimitExceededError as n } from "./index74.js";
+import { NegativeOffsetError as o, PositionOutOfBoundsError as e, RecursiveReadLimitExceededError as n } from "./index.web80.js";
 const h = {
   bytes: new Uint8Array(),
   dataView: new DataView(new ArrayBuffer(0)),

package/dist/esm/{index50.js → index.web53.js}

@@ -1,4 +1,4 @@
-import { BaseError as t } from "./index48.js";
+import { BaseError as t } from "./index.web51.js";
 class $ extends t {
   constructor({ max: e, min: r, signed: s, size: n, value: a }) {
     super(`Number "${a}" is not in safe ${n ? `${n * 8}-bit ${s ? "signed" : "unsigned"} ` : ""}integer range ${e ? `(${r} to ${e})` : `(above ${r})`}`, { name: "IntegerOutOfRangeError" });

package/dist/esm/{index51.js → index.web54.js}

@@ -1,5 +1,5 @@
-import { split as L, rotlSH as T, rotlSL as S, rotlBH as m, rotlBL as F } from "./index76.js";
-import { createHasher as X, Hash as E, anumber as d, u32 as U, swap32IfBE as I, aexists as x, toBytes as P, abytes as k, aoutput as M, clean as y } from "./index77.js";
+import { split as L, rotlSH as T, rotlSL as S, rotlBH as m, rotlBL as F } from "./index.web81.js";
+import { createHasher as X, Hash as E, anumber as d, u32 as U, swap32IfBE as I, aexists as x, toBytes as P, abytes as k, aoutput as M, clean as y } from "./index.web82.js";
 const R = BigInt(0), f = BigInt(1), j = BigInt(2), q = BigInt(7), v = BigInt(256), z = BigInt(113), _ = [], g = [], B = [];
 for (let n = 0, t = f, s = 1, i = 0; n < 24; n++) {
   [s, i] = [i, (2 * s + 3 * i) % 5], _.push(2 * (5 * i + s)), g.push((n + 1) * (n + 2) / 2 % 64);

package/dist/esm/index.web55.js

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

package/dist/esm/index.web56.js

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

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

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

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

@@ -1,4 +1,4 @@
-import { BaseError as t } from "./index48.js";
+import { BaseError as t } from "./index.web51.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/{index56.js → index.web59.js}

@@ -1,14 +1,14 @@
-import { versionedHashVersionKzg as c } from "./index57.js";
-import { maxUint256 as m } from "./index58.js";
-import { InvalidAddressError as s } from "./index59.js";
-import { BaseError as h } from "./index48.js";
-import { EmptyBlobError as P, InvalidVersionedHashSizeError as p, InvalidVersionedHashVersionError as x } from "./index60.js";
-import { InvalidChainIdError as n } from "./index61.js";
-import { FeeCapTooHighError as w, TipAboveFeeCapError as E } from "./index62.js";
-import { isAddress as f } from "./index33.js";
-import { size as F } from "./index38.js";
-import { slice as I } from "./index39.js";
-import { hexToNumber as G } from "./index44.js";
+import { versionedHashVersionKzg as c } from "./index.web60.js";
+import { maxUint256 as m } from "./index.web61.js";
+import { InvalidAddressError as s } from "./index.web62.js";
+import { BaseError as h } from "./index.web51.js";
+import { EmptyBlobError as P, InvalidVersionedHashSizeError as p, InvalidVersionedHashVersionError as x } from "./index.web63.js";
+import { InvalidChainIdError as n } from "./index.web64.js";
+import { FeeCapTooHighError as w, TipAboveFeeCapError as E } from "./index.web65.js";
+import { isAddress as f } from "./index.web36.js";
+import { size as F } from "./index.web41.js";
+import { slice as I } from "./index.web42.js";
+import { hexToNumber as G } from "./index.web47.js";
 function C(t) {
   const { authorizationList: e } = t;
   if (e)

package/dist/esm/index.web6.js

@@ -0,0 +1,192 @@
+import { logOutEndUser as l, refreshAccessToken as c, registerTemporaryWalletSecret as o } from "@coinbase/cdp-api-client";
+import { SignJWT as u } from "./index.web19.js";
+import "viem";
+import { toAuthState as S } from "./index.web12.js";
+import { getPlatformCrypto as n } from "./index.web2.js";
+import { sortKeys as w } from "./index.web16.js";
+const h = 60 * 1e3;
+class A {
+  projectId;
+  authState = null;
+  walletSecret = null;
+  authStateChangeCallbacks = [];
+  initPromise = null;
+  /**
+   * Initializes the token manager.
+   *
+   * @param projectId - The project ID.
+   */
+  constructor(t) {
+    this.projectId = t, this.initPromise = this._doInitialize();
+  }
+  /**
+   * Gets the current user, or null if there is no user signed in.
+   *
+   * @returns The current user.
+   */
+  async getUser() {
+    return this.authState?.user ?? null;
+  }
+  /**
+   * Returns whether the user is signed in - i.e., whether there is an unexpired
+   * access token and user.
+   *
+   * @returns True if the user is signed in, false otherwise.
+   */
+  async isSignedIn() {
+    return this.authState ? Promise.resolve(this.authState.expiresAt > Date.now()) : Promise.resolve(!1);
+  }
+  /**
+   * Signs out the user, clearing all authentication state.
+   */
+  async signOut() {
+    try {
+      await l(this.projectId);
+    } catch {
+    } finally {
+      await this.clearAuthState();
+    }
+  }
+  /**
+   * Adds a callback to be called when the auth state changes.
+   *
+   * @param callback - The function to call when the auth state changes.
+   */
+  addAuthStateChangeCallback(t) {
+    this.authStateChangeCallbacks.push(t), t(this.authState?.user ?? null);
+  }
+  /**
+   * Gets the access token, refreshing it if it is expired. Returns null if the user is not
+   * signed in.
+   *
+   * @returns The access token.
+   */
+  async getToken() {
+    return this.shouldRefreshToken() && await this.refreshAccessToken(), this.authState?.accessToken ?? null;
+  }
+  /**
+   * Gets the currently registered wallet secret ID. Rejects if the user is not signed in.
+   *
+   * @returns The wallet secret ID.
+   */
+  async getWalletSecretId() {
+    if (!await this.isSignedIn())
+      throw new Error("Cannot get wallet secret ID if the user is not signed in");
+    return this.shouldRefreshWalletSecret() && await this.refreshWalletSecret(), this.walletSecret.walletSecretId;
+  }
+  /**
+   * Gets the X-Wallet-Auth header. Rejects if the user is not signed in.
+   *
+   * @param options - The options for the request.
+   * @param options.requestMethod - The HTTP method of the request.
+   * @param options.requestHost - The host of the request.
+   * @param options.requestPath - The path of the request.
+   * @param options.requestData - The data of the request.
+   * @returns The X-Wallet-Auth header.
+   */
+  async getXWalletAuth(t) {
+    if (!await this.isSignedIn())
+      throw new Error("Cannot get X-Wallet-Auth header if the user is not signed in");
+    this.shouldRefreshWalletSecret() && await this.refreshWalletSecret();
+    const e = `${t.requestMethod} ${t.requestHost}${t.requestPath}`, a = Math.floor(Date.now() / 1e3), r = n(), s = {
+      uris: [e]
+    };
+    if (t.requestData && Object.keys(t.requestData).length > 0) {
+      const i = w(t.requestData);
+      s.reqHash = await r.hash(new TextEncoder().encode(JSON.stringify(i)));
+    }
+    return await new u(s).setProtectedHeader({ alg: "ES256", typ: "JWT" }).setIssuedAt(a).setNotBefore(a).setJti(r.generateRandomId()).sign(this.walletSecret.keyPair.privateKey);
+  }
+  /**
+   * Sets the authentication state.
+   *
+   * @param authState - The authentication state.
+   */
+  async setAuthState(t) {
+    this.authState = t, this.authStateChangeCallbacks.forEach((e) => e(this.authState?.user ?? null));
+  }
+  /**
+   * Clears the authentication state.
+   */
+  async clearAuthState() {
+    this.authState = null, this.walletSecret = null, this.authStateChangeCallbacks.forEach((t) => t(null));
+  }
+  /**
+   * Ensures the AuthManager is initialized before proceeding.
+   * If initialization is already in progress, waits for it to complete.
+   */
+  async ensureInitialized() {
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    throw new Error("AuthManager not initialized");
+  }
+  /**
+   * Internal async initialization logic.
+   */
+  async _doInitialize() {
+    try {
+      await this.refreshAccessToken();
+    } catch (t) {
+      console.warn("Failed to refresh access token during initialization:", t);
+    }
+  }
+  /**
+   * Returns whether the token should be refreshed.
+   *
+   * @returns True if the token should be refreshed, false otherwise.
+   */
+  shouldRefreshToken() {
+    return !(this.authState && this.authState.expiresAt > Date.now() + h);
+  }
+  /**
+   * Refreshes the access token and transitions the auth state accordingly.
+   * If a refresh is already in progress, it will wait for that refresh to complete.
+   *
+   * @returns The new access token.
+   */
+  async refreshAccessToken() {
+    try {
+      const t = await c(this.projectId, {
+        grantType: "refresh_token"
+      }), e = S(
+        t.accessToken,
+        t.validUntil,
+        t.endUser
+      );
+      await this.setAuthState(e);
+    } catch {
+      await this.signOut();
+    }
+  }
+  /**
+   * Returns whether the wallet secret should be refreshed.
+   *
+   * @returns True if the wallet secret should be refreshed, false otherwise.
+   */
+  shouldRefreshWalletSecret() {
+    return !(this.walletSecret && this.walletSecret.expiresAt > Date.now() + h);
+  }
+  /**
+   * Refreshes the wallet secret. Assumes the user is signed in.
+   *
+   * @returns The wallet secret.
+   */
+  async refreshWalletSecret() {
+    const t = n(), e = this.walletSecret?.walletSecretId ?? t.generateRandomId(), a = this.walletSecret?.keyPair ?? await t.createKeyPair(), r = this.authState.expiresAt, s = new Date(r).toISOString();
+    this.walletSecret = { walletSecretId: e, keyPair: a, expiresAt: r };
+    try {
+      await o(this.projectId, this.authState.user.userId, {
+        walletSecretId: e,
+        publicKey: a.publicKeyBase64,
+        validUntil: s
+      });
+    } catch (i) {
+      throw this.walletSecret = null, i;
+    }
+  }
+}
+export {
+  A as AuthManager
+};

package/dist/esm/index.web60.js

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

package/dist/esm/index.web61.js

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

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

@@ -1,4 +1,4 @@
-import { BaseError as r } from "./index48.js";
+import { BaseError as r } from "./index.web51.js";
 class d extends r {
   constructor({ address: s }) {
     super(`Address "${s}" is invalid.`, {

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

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

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

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