@coinbase/cdp-core 0.0.32 → 0.0.34

package/dist/native/index.native6.js

@@ -1,192 +1,332 @@
-import { logOutEndUser as l, refreshAccessToken as c, registerTemporaryWalletSecret as o } from "@coinbase/cdp-api-client";
-import { SignJWT as u } from "./index.native20.js";
+import { configureCdpApiClient as h, setAuthManager as I, initiateAuthentication as A, createEndUserSolanaAccount as v, createEndUserEvmAccount as k, createEndUserEvmSmartAccount as d, verifyEmailAuthentication as S, verifySmsAuthentication as E, signEvmHashWithEndUserAccount as U, signEvmTransactionWithEndUserAccount as T, signSolanaTransactionWithEndUserAccount as M, sendEvmTransactionWithEndUserAccount as j, sendSolanaTransactionWithEndUserAccount as P, signEvmMessageWithEndUserAccount as O, signEvmTypedDataWithEndUserAccount as C, sendUserOperationWithEndUserAccount as x, getUserOperationWithEndUserAccount as W, exportEndUserEvmAccount as H } from "@coinbase/cdp-api-client";
+import { AuthManager as b } from "./index.native7.js";
+import { toAuthState as u } from "./index.native14.js";
+import { withAuth as o } from "./index.native15.js";
+import { MockAuthManager as K } from "./index.native16.js";
+import { mockUser as g } from "./index.native17.js";
+import { getPlatformServices as l, getPlatformCrypto as D } from "./index.native5.js";
+import { isChainSupportedForCDPSends as _ } from "./index.native18.js";
+import { getConfig as n, setCoreAuthManager as m, getCoreAuthManager as a, setConfig as N } from "./index.native19.js";
 import "viem";
-import { toAuthState as S } from "./index.native13.js";
-import { getPlatformCrypto as n } from "./index.native4.js";
-import { sortKeys as w } from "./index.native17.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();
+import { serializeTransaction as w } from "./index.native20.js";
+const R = async (e) => {
+  if (!e.projectId)
+    throw new Error("Project ID is required");
+  let r;
+  try {
+    r = n().projectId !== e.projectId;
+  } catch {
+    r = !0;
   }
-  /**
-   * Gets the current user, or null if there is no user signed in.
-   *
-   * @returns The current user.
-   */
-  async getUser() {
-    return this.authState?.user ?? null;
+  if (N(e), n().useMock) {
+    m(new K(n().projectId));
+    return;
   }
-  /**
-   * 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);
+  let t;
+  try {
+    const s = l();
+    t = s.secureStorage ? {
+      getRefreshToken: () => s.secureStorage.getItem("cdp_refresh_token"),
+      setRefreshToken: (c) => s.secureStorage.setItem("cdp_refresh_token", c),
+      removeRefreshToken: () => s.secureStorage.removeItem("cdp_refresh_token")
+    } : void 0;
+  } catch {
+    t = void 0;
   }
-  /**
-   * 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);
+  if (h({
+    debugging: n().debugging,
+    basePath: n().basePath,
+    refreshTokenStorage: t
+  }), r) {
+    const s = new b(n().projectId);
+    m(s), I(s);
   }
-  /**
-   * 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;
+  await a().ensureInitialized();
+}, ee = async (e) => p({
+  email: e.email,
+  type: "email"
+}), re = async (e) => p({
+  phoneNumber: e.phoneNumber,
+  type: "sms"
+}), te = async (e) => y(
+  e,
+  "Mock email OTP verified",
+  (r, t) => S(r, t)
+), ne = async (e) => y(
+  e,
+  "Mock SMS OTP verified",
+  (r, t) => E(r, t)
+), se = async () => a().getUser(), ae = async () => a().isSignedIn(), ce = async () => {
+  if (n().useMock) {
+    await a().signOut();
+    return;
   }
-  /**
-   * 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;
+  if (!await a().isSignedIn())
+    throw new Error("User not signed in");
+  await a().signOut();
+  try {
+    const r = l();
+    if (r.secureStorage)
+      try {
+        await r.secureStorage.removeItem("cdp_refresh_token");
+      } catch (t) {
+        console.warn("Failed to clear stored refresh token:", t);
+      }
+  } catch {
   }
-  /**
-   * 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)));
+}, oe = async () => a().getToken(), ie = (e) => {
+  a().addAuthStateChangeCallback(e);
+}, ue = async (e) => n().useMock ? { signature: "0x0" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await U(n().projectId, r.userId, {
+    hash: e.hash,
+    address: e.evmAccount,
+    walletSecretId: t
+  })).signature
+})), de = async (e) => n().useMock ? { signedTransaction: "0x0" } : o(e, a(), async ({ user: r, walletSecretId: t }) => {
+  const s = w(e.transaction);
+  return {
+    signedTransaction: (await T(
+      n().projectId,
+      r.userId,
+      {
+        transaction: s,
+        address: e.evmAccount,
+        walletSecretId: t
+      }
+    )).signedTransaction
+  };
+}), ge = async (e) => n().useMock ? { signedTransaction: "mock-signed-transaction" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  signedTransaction: (await M(
+    n().projectId,
+    r.userId,
+    {
+      transaction: e.transaction,
+      address: e.solanaAccount,
+      walletSecretId: t
     }
-    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;
+  )).signedTransaction
+})), me = async (e) => {
+  if (!_(e.network))
+    throw new Error(`Chain ${e.network} is not supported by the CDP Apis`);
+  if (n().useMock)
+    return { transactionHash: "0x0" };
+  const r = w(e.transaction);
+  return o(e, a(), async ({ user: t, walletSecretId: s }) => ({
+    transactionHash: (await j(
+      n().projectId,
+      t.userId,
+      {
+        transaction: r,
+        address: e.evmAccount,
+        walletSecretId: s,
+        network: e.network
+      }
+    )).transactionHash
+  }));
+}, le = async (e) => n().useMock ? { transactionSignature: "mock-signature" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  transactionSignature: (await P(
+    n().projectId,
+    r.userId,
+    {
+      transaction: e.transaction,
+      address: e.solanaAccount,
+      walletSecretId: t,
+      network: e.network
     }
-    throw new Error("AuthManager not initialized");
-  }
-  /**
-   * Internal async initialization logic.
-   */
-  async _doInitialize() {
+  )).transactionSignature
+})), we = async (e) => n().useMock ? { signature: "0x0" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await O(n().projectId, r.userId, {
+    message: e.message,
+    address: e.evmAccount,
+    walletSecretId: t
+  })).signature
+})), pe = async (e) => n().useMock ? { signature: "0x0" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await C(n().projectId, r.userId, {
+    typedData: e.typedData,
+    address: e.evmAccount,
+    walletSecretId: t
+  })).signature
+})), ye = async (e) => n().useMock ? {
+  userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
+} : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  userOperationHash: (await x(
+    n().projectId,
+    r.userId,
+    e.evmSmartAccount,
+    {
+      network: e.network,
+      calls: e.calls.map((c) => ({
+        to: c.to,
+        value: String(c.value ?? 0n),
+        data: c.data ?? "0x"
+      })),
+      walletSecretId: t,
+      useCdpPaymaster: e.useCdpPaymaster ?? !1,
+      paymasterUrl: e.paymasterUrl
+    }
+  )).userOpHash
+})), fe = async (e) => n().useMock ? {
+  userOpHash: e.userOperationHash,
+  network: e.network,
+  calls: [
+    {
+      to: "0x1234567890123456789012345678901234567890",
+      value: "0",
+      data: "0x"
+    }
+  ],
+  status: "complete",
+  transactionHash: "0x9876543210987654321098765432109876543210987654321098765432109876",
+  receipts: []
+} : o(e, a(), async ({ user: r }) => await W(
+  n().projectId,
+  r.userId,
+  e.evmSmartAccount,
+  e.userOperationHash
+)), he = async (e) => {
+  if (n().useMock)
+    return {
+      privateKey: "mock-private-key"
+    };
+  const r = D(), t = await r.createExportKeyPair();
+  return o(e, a(), async ({ user: s, walletSecretId: c }) => {
+    const i = await H(n().projectId, s.userId, {
+      address: e.evmAccount,
+      walletSecretId: c,
+      exportEncryptionKey: t.publicKeyBase64
+    });
+    return {
+      privateKey: await r.decryptWithPrivateKey(
+        t.privateKey,
+        i.encryptedPrivateKey
+      )
+    };
+  });
+}, p = async (e) => {
+  if (n().useMock)
+    return {
+      message: "Mock sign in initiated",
+      flowId: "mock-flow-id"
+    };
+  if (await a().isSignedIn())
+    throw new Error("User is already authenticated. Please sign out first.");
+  const t = await A(n().projectId, e);
+  return {
+    flowId: t.flowId,
+    message: t.message
+  };
+}, y = async (e, r, t) => {
+  if (n().useMock)
+    return await a().setAuthState({
+      accessToken: "mock-access-token",
+      expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
+      user: g
+    }), {
+      message: r,
+      user: g,
+      isNewUser: !1
+    };
+  if (await a().isSignedIn())
+    throw new Error("User is already authenticated. Please sign out first.");
+  const c = await t(n().projectId, {
+    flowId: e.flowId,
+    otp: e.otp
+  }), i = u(
+    c.accessToken,
+    c.validUntil,
+    c.endUser
+  );
+  return await a().setAuthState(i), n().createAccountOnLogin === "solana" ? F({ authResponse: c, authState: i }) : z({ authResponse: c, authState: i });
+}, z = async ({
+  authResponse: e,
+  authState: r
+}) => {
+  if (!r.user.evmAccounts || r.user.evmAccounts.length === 0)
     try {
-      await this.refreshAccessToken();
-    } catch (t) {
-      console.warn("Failed to refresh access token during initialization:", t);
+      const s = await a().getWalletSecretId();
+      let c = await k(n().projectId, r.user.userId, {
+        walletSecretId: s
+      });
+      if (n().createAccountOnLogin === "evm-smart") {
+        const [i] = c.evmAccounts;
+        c = await d(
+          n().projectId,
+          r.user.userId,
+          {
+            owner: i,
+            enableSpendPermissions: !1
+            // Defaulting to false until the feature is ready.
+          }
+        );
+      }
+      r = u(e.accessToken, e.validUntil, c), await a().setAuthState(r);
+    } catch (s) {
+      throw new Error(`Failed to create EVM account: ${s}`);
     }
-  }
-  /**
-   * 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() {
+  if (n().createAccountOnLogin === "evm-smart" && (!r.user.evmSmartAccounts || r.user.evmSmartAccounts.length === 0))
     try {
-      const t = await c(this.projectId, {
-        grantType: "refresh_token"
-      }), e = S(
-        t.accessToken,
-        t.validUntil,
-        t.endUser
+      const [s] = r.user.evmAccounts, c = await d(
+        n().projectId,
+        r.user.userId,
+        {
+          owner: s,
+          enableSpendPermissions: !1
+          // Defaulting to false until the feature is ready.
+        }
       );
-      await this.setAuthState(e);
-    } catch {
-      await this.signOut();
+      r = u(e.accessToken, e.validUntil, c), await a().setAuthState(r);
+    } catch (s) {
+      throw new Error(`Failed to create EVM Smart Account: ${s}`);
     }
-  }
-  /**
-   * 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 };
+  const t = await a().getUser();
+  return {
+    message: e.message,
+    user: t,
+    isNewUser: e.isNewEndUser
+  };
+}, F = async ({
+  authResponse: e,
+  authState: r
+}) => {
+  if (!r.user.solanaAccounts || r.user.solanaAccounts.length === 0)
     try {
-      await o(this.projectId, this.authState.user.userId, {
-        walletSecretId: e,
-        publicKey: a.publicKeyBase64,
-        validUntil: s
-      });
-    } catch (i) {
-      throw this.walletSecret = null, i;
+      const s = await a().getWalletSecretId(), c = await v(
+        n().projectId,
+        r.user.userId,
+        {
+          walletSecretId: s
+        }
+      );
+      r = u(e.accessToken, e.validUntil, c), await a().setAuthState(r);
+    } catch (s) {
+      throw new Error(`Failed to create Solana account: ${s}`);
     }
-  }
-}
+  const t = await a().getUser();
+  return {
+    message: e.message,
+    user: t,
+    isNewUser: e.isNewEndUser
+  };
+};
 export {
-  A as AuthManager
+  he as exportEvmAccount,
+  oe as getAccessToken,
+  se as getCurrentUser,
+  fe as getUserOperation,
+  R as initialize,
+  ae as isSignedIn,
+  ie as onAuthStateChange,
+  me as sendEvmTransaction,
+  le as sendSolanaTransaction,
+  ye as sendUserOperation,
+  ue as signEvmHash,
+  we as signEvmMessage,
+  de as signEvmTransaction,
+  pe as signEvmTypedData,
+  ee as signInWithEmail,
+  re as signInWithSms,
+  ce as signOut,
+  ge as signSolanaTransaction,
+  te as verifyEmailOTP,
+  ne as verifySmsOTP
 };

package/dist/native/index.native60.js

@@ -1,45 +1,17 @@
-import { BaseError as t } from "./index.native53.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(`
-`);
-}
-class c extends t {
-  constructor({ v: r }) {
-    super(`Invalid \`v\` value "${r}". Expected 27 or 28.`, {
-      name: "InvalidLegacyVError"
-    });
-  }
-}
-class d extends t {
-  constructor({ transaction: r }) {
-    super("Cannot infer a transaction type from provided transaction.", {
-      metaMessages: [
-        "Provided Transaction:",
-        "{",
-        i(r),
-        "}",
-        "",
-        "To infer the type, either provide:",
-        "- a `type` to the Transaction, or",
-        "- an EIP-1559 Transaction with `maxFeePerGas`, or",
-        "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
-        "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
-        "- an EIP-7702 Transaction with `authorizationList`, or",
-        "- a Legacy Transaction with `gasPrice`"
-      ],
-      name: "InvalidSerializableTransactionError"
-    });
-  }
-}
-class l extends t {
-  constructor({ storageKey: r }) {
-    super(`Size for storage key "${r}" is invalid. Expected 32 bytes. Got ${Math.floor((r.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
-  }
+import { InvalidSerializableTransactionError as f } from "./index.native61.js";
+function d(e) {
+  if (e.type)
+    return e.type;
+  if (typeof e.authorizationList < "u")
+    return "eip7702";
+  if (typeof e.blobs < "u" || typeof e.blobVersionedHashes < "u" || typeof e.maxFeePerBlobGas < "u" || typeof e.sidecars < "u")
+    return "eip4844";
+  if (typeof e.maxFeePerGas < "u" || typeof e.maxPriorityFeePerGas < "u")
+    return "eip1559";
+  if (typeof e.gasPrice < "u")
+    return typeof e.accessList < "u" ? "eip2930" : "legacy";
+  throw new f({ transaction: e });
 }
 export {
-  c as InvalidLegacyVError,
-  d as InvalidSerializableTransactionError,
-  l as InvalidStorageKeySizeError,
-  i as prettyPrint
+  d as getTransactionType
 };