@coinbase/cdp-core 0.0.17 → 0.0.19

package/dist/esm/index2.js

@@ -1,176 +1,190 @@
-import { configureCdpApiClient as w, setAuthManager as h, initiateAuthentication as y, verifyEmailAuthentication as f, createEndUserEvmAccount as I, signEvmHashWithEndUserAccount as l, signEvmTransactionWithEndUserAccount as A, sendEvmTransactionWithEndUserAccount as v, signEvmMessageWithEndUserAccount as E, signEvmTypedDataWithEndUserAccount as k, exportEndUserEvmAccount as M } from "@coinbase/cdp-api-client";
-import { AuthManager as S } from "./index6.js";
-import { toAuthState as u } from "./index7.js";
-import { withAuth as i } from "./index8.js";
-import { createExportKeyPair as U } from "./index9.js";
-import { decryptWithPrivateKey as C } from "./index10.js";
-import { MockAuthManager as T } from "./index11.js";
-import { mockUser as d } from "./index12.js";
-import { isChainSupportedForCDPSends as j } from "./index13.js";
-import { getConfig as r, setCoreAuthManager as g, getCoreAuthManager as n, setConfig as P } from "./index14.js";
+import { configureCdpApiClient as I, setAuthManager as l, initiateAuthentication as v, createEndUserEvmAccount as A, verifyEmailAuthentication as E, verifySmsAuthentication as k, signEvmHashWithEndUserAccount as S, signEvmTransactionWithEndUserAccount as M, sendEvmTransactionWithEndUserAccount as T, signEvmMessageWithEndUserAccount as U, signEvmTypedDataWithEndUserAccount as C, exportEndUserEvmAccount as j } from "@coinbase/cdp-api-client";
+import { AuthManager as P } from "./index6.js";
+import { toAuthState as d } from "./index7.js";
+import { withAuth as o } from "./index8.js";
+import { createExportKeyPair as x } from "./index9.js";
+import { decryptWithPrivateKey as b } from "./index10.js";
+import { MockAuthManager as K } from "./index11.js";
+import { mockUser as g } from "./index12.js";
+import { isChainSupportedForCDPSends as W } from "./index13.js";
+import { getConfig as n, setCoreAuthManager as m, getCoreAuthManager as s, setConfig as D } from "./index14.js";
 import "viem";
-import { serializeTransaction as m } from "./index15.js";
-const B = async (e) => {
+import { serializeTransaction as p } from "./index15.js";
+const Q = async (e) => {
   if (!e.projectId)
     throw new Error("Project ID is required");
-  let s;
+  let r;
   try {
-    s = r().projectId !== e.projectId;
+    r = n().projectId !== e.projectId;
   } catch {
-    s = !0;
+    r = !0;
   }
-  if (P(e), r().useMock) {
-    g(new T(r().projectId));
+  if (D(e), n().useMock) {
+    m(new K(n().projectId));
     return;
   }
-  if (w({
-    debugging: r().debugging,
-    basePath: r().basePath
-  }), s) {
-    const t = new S(r().projectId);
-    g(t), h(t);
+  if (I({
+    debugging: n().debugging,
+    basePath: n().basePath
+  }), r) {
+    const t = new P(n().projectId);
+    m(t), l(t);
   }
-  await n().ensureInitialized();
-}, V = async (e) => {
-  if (r().useMock)
-    return {
-      message: "Mock sign in initiated",
-      flowId: "mock-flow-id"
-    };
-  if (await n().isSignedIn())
-    throw new Error("User is already authenticated. Please sign out first.");
-  const t = await y(r().projectId, {
-    email: e.email,
-    type: "email"
-  });
-  return {
-    flowId: t.flowId,
-    message: t.message
-  };
-}, G = async (e) => {
-  if (r().useMock)
-    return await n().setAuthState({
-      accessToken: "mock-access-token",
-      expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
-      user: d
-    }), {
-      message: "Mock email OTP verified",
-      user: d,
-      isNewUser: !1
-    };
-  if (await n().isSignedIn())
-    throw new Error("User is already authenticated. Please sign out first.");
-  const t = await f(r().projectId, {
-    flowId: e.flowId,
-    otp: e.otp
-  });
-  let a = u(t.accessToken, t.validUntil, t.endUser);
-  if (await n().setAuthState(a), !a.user.evmAccounts || a.user.evmAccounts.length === 0)
-    try {
-      const o = await n().getWalletSecretId(), p = await I(r().projectId, a.user.userId, {
-        walletSecretId: o
-      });
-      a = u(t.accessToken, t.validUntil, p), await n().setAuthState(a);
-    } catch (o) {
-      throw new Error(`Failed to create EVM account: ${o}`);
-    }
-  const c = await n().getUser();
-  return {
-    message: t.message,
-    user: c,
-    isNewUser: t.isNewEndUser
-  };
-}, J = async () => n().getUser(), L = async () => n().isSignedIn(), Q = async () => {
-  if (r().useMock) {
-    await n().signOut();
+  await s().ensureInitialized();
+}, R = async (e) => h({
+  email: e.email,
+  type: "email"
+}), X = async (e) => h({
+  phoneNumber: e.phoneNumber,
+  type: "sms"
+}), Y = async (e) => w(
+  e,
+  "Mock email OTP verified",
+  (r, t) => E(r, t)
+), Z = async (e) => w(
+  e,
+  "Mock SMS OTP verified",
+  (r, t) => k(r, t)
+), _ = async () => s().getUser(), ee = async () => s().isSignedIn(), te = async () => {
+  if (n().useMock) {
+    await s().signOut();
     return;
   }
-  if (!await n().isSignedIn())
+  if (!await s().isSignedIn())
     throw new Error("User not signed in");
-  await n().signOut();
-}, R = (e) => {
-  n().addAuthStateChangeCallback(e);
-}, X = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
-  signature: (await l(r().projectId, s.userId, {
+  await s().signOut();
+}, ne = async () => s().getToken(), re = (e) => {
+  s().addAuthStateChangeCallback(e);
+}, se = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await S(n().projectId, r.userId, {
     hash: e.hash,
     address: e.evmAccount,
     walletSecretId: t
   })).signature
-})), Y = async (e) => r().useMock ? { signedTransaction: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => {
-  const a = m(e.transaction);
+})), ae = async (e) => n().useMock ? { signedTransaction: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => {
+  const i = p(e.transaction);
   return {
-    signedTransaction: (await A(
-      r().projectId,
-      s.userId,
+    signedTransaction: (await M(
+      n().projectId,
+      r.userId,
       {
-        transaction: a,
+        transaction: i,
         address: e.evmAccount,
         walletSecretId: t
       }
     )).signedTransaction
   };
-}), Z = async (e) => {
-  if (!j(e.network))
+}), ie = async (e) => {
+  if (!W(e.network))
     throw new Error(`Chain ${e.network} is not supported by the CDP Apis`);
-  if (r().useMock)
+  if (n().useMock)
     return { transactionHash: "0x0" };
-  const s = m(e.transaction);
-  return i(e, n(), async ({ user: t, walletSecretId: a }) => ({
-    transactionHash: (await v(
-      r().projectId,
+  const r = p(e.transaction);
+  return o(e, s(), async ({ user: t, walletSecretId: i }) => ({
+    transactionHash: (await T(
+      n().projectId,
       t.userId,
       {
-        transaction: s,
+        transaction: r,
         address: e.evmAccount,
-        walletSecretId: a,
+        walletSecretId: i,
         network: e.network
       }
     )).transactionHash
   }));
-}, _ = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
-  signature: (await E(r().projectId, s.userId, {
+}, ce = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await U(n().projectId, r.userId, {
     message: e.message,
     address: e.evmAccount,
     walletSecretId: t
   })).signature
-})), ee = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
-  signature: (await k(r().projectId, s.userId, {
+})), oe = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await C(n().projectId, r.userId, {
     typedData: e.typedData,
     address: e.evmAccount,
     walletSecretId: t
   })).signature
-})), te = async (e) => {
-  if (r().useMock)
+})), ue = async (e) => {
+  if (n().useMock)
     return {
       privateKey: "mock-private-key"
     };
-  const s = await U();
-  return i(e, n(), async ({ user: t, walletSecretId: a }) => {
-    const c = await M(r().projectId, t.userId, {
+  const r = await x();
+  return o(e, s(), async ({ user: t, walletSecretId: i }) => {
+    const a = await j(n().projectId, t.userId, {
       address: e.evmAccount,
-      walletSecretId: a,
-      exportEncryptionKey: s.publicKeyBase64
+      walletSecretId: i,
+      exportEncryptionKey: r.publicKeyBase64
     });
     return {
-      privateKey: await C(
-        s.privateKey,
-        c.encryptedPrivateKey
+      privateKey: await b(
+        r.privateKey,
+        a.encryptedPrivateKey
       )
     };
   });
+}, h = async (e) => {
+  if (n().useMock)
+    return {
+      message: "Mock sign in initiated",
+      flowId: "mock-flow-id"
+    };
+  if (await s().isSignedIn())
+    throw new Error("User is already authenticated. Please sign out first.");
+  const t = await v(n().projectId, e);
+  return {
+    flowId: t.flowId,
+    message: t.message
+  };
+}, w = async (e, r, t) => {
+  if (n().useMock)
+    return await s().setAuthState({
+      accessToken: "mock-access-token",
+      expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
+      user: g
+    }), {
+      message: r,
+      user: g,
+      isNewUser: !1
+    };
+  if (await s().isSignedIn())
+    throw new Error("User is already authenticated. Please sign out first.");
+  const a = await t(n().projectId, {
+    flowId: e.flowId,
+    otp: e.otp
+  });
+  let c = d(a.accessToken, a.validUntil, a.endUser);
+  if (await s().setAuthState(c), !c.user.evmAccounts || c.user.evmAccounts.length === 0)
+    try {
+      const u = await s().getWalletSecretId(), f = await A(n().projectId, c.user.userId, {
+        walletSecretId: u
+      });
+      c = d(a.accessToken, a.validUntil, f), await s().setAuthState(c);
+    } catch (u) {
+      throw new Error(`Failed to create EVM account: ${u}`);
+    }
+  const y = await s().getUser();
+  return {
+    message: a.message,
+    user: y,
+    isNewUser: a.isNewEndUser
+  };
 };
 export {
-  te as exportEvmAccount,
-  J as getCurrentUser,
-  B as initialize,
-  L as isSignedIn,
-  R as onAuthStateChange,
-  Z as sendEvmTransaction,
-  X as signEvmHash,
-  _ as signEvmMessage,
-  Y as signEvmTransaction,
-  ee as signEvmTypedData,
-  V as signInWithEmail,
-  Q as signOut,
-  G as verifyEmailOTP
+  ue as exportEvmAccount,
+  ne as getAccessToken,
+  _ as getCurrentUser,
+  Q as initialize,
+  ee as isSignedIn,
+  re as onAuthStateChange,
+  ie as sendEvmTransaction,
+  se as signEvmHash,
+  ce as signEvmMessage,
+  ae as signEvmTransaction,
+  oe as signEvmTypedData,
+  R as signInWithEmail,
+  X as signInWithSms,
+  te as signOut,
+  Y as verifyEmailOTP,
+  Z as verifySmsOTP
 };

package/dist/esm/index20.js

@@ -1,58 +1,7 @@
-import { chainConfig as a } from "./index80.js";
-import { defineChain as t } from "./index25.js";
-const e = 11155111, r = /* @__PURE__ */ t({
-  ...a,
-  id: 84532,
-  network: "base-sepolia",
-  name: "Base Sepolia",
-  nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
-  rpcUrls: {
-    default: {
-      http: ["https://sepolia.base.org"]
-    }
-  },
-  blockExplorers: {
-    default: {
-      name: "Basescan",
-      url: "https://sepolia.basescan.org",
-      apiUrl: "https://api-sepolia.basescan.org/api"
-    }
-  },
-  contracts: {
-    ...a.contracts,
-    disputeGameFactory: {
-      [e]: {
-        address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
-      }
-    },
-    l2OutputOracle: {
-      [e]: {
-        address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
-      }
-    },
-    portal: {
-      [e]: {
-        address: "0x49f53e41452c74589e85ca1677426ba426459e85",
-        blockCreated: 4446677
-      }
-    },
-    l1StandardBridge: {
-      [e]: {
-        address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
-        blockCreated: 4446677
-      }
-    },
-    multicall3: {
-      address: "0xca11bde05977b3631167028862be2a173976ca11",
-      blockCreated: 1059647
-    }
-  },
-  testnet: !0,
-  sourceId: e
-});
-({
-  ...r
-});
+const h = async (t) => {
+  const a = await window.crypto.subtle.digest("SHA-256", t), r = new Uint8Array(a);
+  return Array.from(r).map((s) => s.toString(16).padStart(2, "0")).join("");
+};
 export {
-  r as baseSepolia
+  h as hash
 };

package/dist/esm/index21.js

@@ -1,43 +1,162 @@
-import { CompactSign as i } from "./index70.js";
-import { JWTInvalid as r } from "./index71.js";
-import { JWTClaimsBuilder as n } from "./index72.js";
-class d {
-  #s;
-  #t;
-  constructor(t = {}) {
-    this.#t = new n(t);
-  }
-  setIssuer(t) {
-    return this.#t.iss = t, this;
-  }
-  setSubject(t) {
-    return this.#t.sub = t, this;
-  }
-  setAudience(t) {
-    return this.#t.aud = t, this;
-  }
-  setJti(t) {
-    return this.#t.jti = t, this;
-  }
-  setNotBefore(t) {
-    return this.#t.nbf = t, this;
-  }
-  setExpirationTime(t) {
-    return this.#t.exp = t, this;
-  }
-  setIssuedAt(t) {
-    return this.#t.iat = t, this;
-  }
-  setProtectedHeader(t) {
-    return this.#s = t, this;
-  }
-  async sign(t, e) {
-    const s = new i(this.#t.data());
-    if (s.setProtectedHeader(this.#s), Array.isArray(this.#s?.crit) && this.#s.crit.includes("b64") && this.#s.b64 === !1)
-      throw new r("JWTs MUST NOT use unencoded payload");
-    return s.sign(t, e);
+const H = (m) => (h, n, r) => {
+  const s = r.subscribe;
+  return r.subscribe = (c, i, a) => {
+    let l = c;
+    if (i) {
+      const g = a?.equalityFn || Object.is;
+      let v = c(r.getState());
+      l = (f) => {
+        const u = c(f);
+        if (!g(v, u)) {
+          const y = v;
+          i(v = u, y);
+        }
+      }, a?.fireImmediately && i(v, v);
+    }
+    return s(l);
+  }, m(h, n, r);
+}, R = H;
+function F(m, h) {
+  let n;
+  try {
+    n = m();
+  } catch {
+    return;
   }
+  return {
+    getItem: (s) => {
+      var e;
+      const c = (a) => a === null ? null : JSON.parse(a, void 0), i = (e = n.getItem(s)) != null ? e : null;
+      return i instanceof Promise ? i.then(c) : c(i);
+    },
+    setItem: (s, e) => n.setItem(s, JSON.stringify(e, void 0)),
+    removeItem: (s) => n.removeItem(s)
+  };
 }
+const p = (m) => (h) => {
+  try {
+    const n = m(h);
+    return n instanceof Promise ? n : {
+      then(r) {
+        return p(r)(n);
+      },
+      catch(r) {
+        return this;
+      }
+    };
+  } catch (n) {
+    return {
+      then(r) {
+        return this;
+      },
+      catch(r) {
+        return p(r)(n);
+      }
+    };
+  }
+}, O = (m, h) => (n, r, s) => {
+  let e = {
+    storage: F(() => localStorage),
+    partialize: (t) => t,
+    version: 0,
+    merge: (t, S) => ({
+      ...S,
+      ...t
+    }),
+    ...h
+  }, c = !1;
+  const i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
+  let l = e.storage;
+  if (!l)
+    return m(
+      (...t) => {
+        console.warn(
+          `[zustand persist middleware] Unable to update item '${e.name}', the given storage is currently unavailable.`
+        ), n(...t);
+      },
+      r,
+      s
+    );
+  const g = () => {
+    const t = e.partialize({ ...r() });
+    return l.setItem(e.name, {
+      state: t,
+      version: e.version
+    });
+  }, v = s.setState;
+  s.setState = (t, S) => {
+    v(t, S), g();
+  };
+  const f = m(
+    (...t) => {
+      n(...t), g();
+    },
+    r,
+    s
+  );
+  s.getInitialState = () => f;
+  let u;
+  const y = () => {
+    var t, S;
+    if (!l) return;
+    c = !1, i.forEach((o) => {
+      var d;
+      return o((d = r()) != null ? d : f);
+    });
+    const b = ((S = e.onRehydrateStorage) == null ? void 0 : S.call(e, (t = r()) != null ? t : f)) || void 0;
+    return p(l.getItem.bind(l))(e.name).then((o) => {
+      if (o)
+        if (typeof o.version == "number" && o.version !== e.version) {
+          if (e.migrate) {
+            const d = e.migrate(
+              o.state,
+              o.version
+            );
+            return d instanceof Promise ? d.then((I) => [!0, I]) : [!0, d];
+          }
+          console.error(
+            "State loaded from storage couldn't be migrated since no migrate function was provided"
+          );
+        } else
+          return [!1, o.state];
+      return [!1, void 0];
+    }).then((o) => {
+      var d;
+      const [I, _] = o;
+      if (u = e.merge(
+        _,
+        (d = r()) != null ? d : f
+      ), n(u, !0), I)
+        return g();
+    }).then(() => {
+      b?.(u, void 0), u = r(), c = !0, a.forEach((o) => o(u));
+    }).catch((o) => {
+      b?.(void 0, o);
+    });
+  };
+  return s.persist = {
+    setOptions: (t) => {
+      e = {
+        ...e,
+        ...t
+      }, t.storage && (l = t.storage);
+    },
+    clearStorage: () => {
+      l?.removeItem(e.name);
+    },
+    getOptions: () => e,
+    rehydrate: () => y(),
+    hasHydrated: () => c,
+    onHydrate: (t) => (i.add(t), () => {
+      i.delete(t);
+    }),
+    onFinishHydration: (t) => (a.add(t), () => {
+      a.delete(t);
+    })
+  }, e.skipHydration || y(), u || f;
+}, w = O;
 export {
-  d as SignJWT
+  F as createJSONStorage,
+  w as persist,
+  R as subscribeWithSelector
 };

package/dist/esm/index22.js

@@ -1,19 +1,50 @@
-async function n() {
-  const e = await window.crypto.subtle.generateKey(
-    {
-      name: "ECDSA",
-      namedCurve: "P-256"
-      // secp256r1
-    },
-    !1,
-    // Do not allow key export.
-    ["sign", "verify"]
-    // Key usages
-  ), r = await window.crypto.subtle.exportKey("spki", e.publicKey), t = new Uint8Array(r), a = btoa(
-    Array.from(t).map((i) => String.fromCharCode(i)).join("")
-  );
-  return { privateKey: e.privateKey, publicKeyBase64: a };
+class n {
+  events = {};
+  /**
+   * Add an event listener.
+   *
+   * @param event - The name of the event to listen for.
+   * @param listener - The function to call when the event is emitted.
+   */
+  on(e, s) {
+    this.events[e] || (this.events[e] = []), this.events[e].push(s);
+  }
+  /**
+   * Remove an event listener.
+   *
+   * @param event - The name of the event to remove the listener from.
+   * @param listener - The function to remove from the event listeners.
+   */
+  removeListener(e, s) {
+    if (!this.events[e])
+      return;
+    const t = this.events[e].indexOf(s);
+    t > -1 && this.events[e].splice(t, 1);
+  }
+  /**
+   * Emit an event.
+   *
+   * @param event - The name of the event to emit.
+   * @param args - The arguments to pass to the event listeners.
+   */
+  emit(e, ...s) {
+    this.events[e] && this.events[e].forEach((t) => {
+      try {
+        t(...s);
+      } catch (i) {
+        console.error(`Error in event listener for ${e}:`, i);
+      }
+    });
+  }
+  /**
+   * Remove all listeners for an event.
+   *
+   * @param event - The name of the event to remove all listeners from. If not provided, removes all listeners for all events.
+   */
+  removeAllListeners(e) {
+    e ? delete this.events[e] : this.events = {};
+  }
 }
 export {
-  n as createKeyPair
+  n as EventEmitter
 };