@coinbase/cdp-core 0.0.79 → 0.0.81

package/dist/esm/index.web35.js

@@ -1,124 +1,16 @@
-import { hashTypedData as i, serializeErc6492Signature as u, encodeFunctionData as m, pad as g, getTypesForEIP712Domain as A, hashMessage as d } from "viem";
-import { getCurrentUserSync as h } from "./index.web13.js";
-import { signEvmHash as o, signEvmTypedData as l, signEvmTransaction as f, signEvmMessage as y } from "./index.web9.js";
 import "@coinbase/cdp-api-client";
-import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as p, COINBASE_SMART_WALLET_FACTORY_ABI as v } from "./index.web60.js";
-import { signAndWrapTypedDataForSmartAccount as E } from "./index.web61.js";
-import { toAccount as T } from "./index.web62.js";
-function _(n) {
-  const r = h();
-  if (!r || !r.evmAccountObjects?.length && !r.evmSmartAccountObjects?.length)
-    throw new Error(
-      "No accounts found - user must be authenticated and have at least one EVM account or smart account"
-    );
-  const c = r.evmAccountObjects?.some((e) => e.address === n) ?? !1, s = r.evmSmartAccountObjects?.some((e) => e.address === n) ?? !1;
-  if (!c && !s)
-    throw new Error(`Cannot sign for address ${n} - not authorized for this account`);
-  return T({
-    address: n,
-    /**
-     * Signs a message using CDP's message signing functionality.
-     * Supports string messages, hex strings, and byte arrays.
-     *
-     * @param root0 - The parameters object
-     * @param root0.message - The message to sign, can be a string, hex string, or byte array
-     * @returns The signature as a hex string
-     */
-    async signMessage({ message: e }) {
-      let t;
-      if (typeof e == "string")
-        t = (await y({
-          evmAccount: n,
-          message: e
-        })).signature;
-      else if ("raw" in e) {
-        const a = d(e);
-        t = (await o({
-          evmAccount: n,
-          hash: a
-        })).signature;
-      } else
-        throw new Error("Unsupported message format");
-      return t;
-    },
-    /**
-     * Signs a transaction using CDP's transaction signing functionality.
-     * Converts Viem's transaction format to CDP's AllowedEvmTransactionType.
-     *
-     * @param transaction - The transaction to sign in Viem's format
-     * @returns The signature as a hex string
-     */
-    async signTransaction(e) {
-      const t = {
-        to: e.to,
-        value: e.value,
-        data: e.data,
-        nonce: e.nonce,
-        gas: e.gas,
-        chainId: e.chainId ?? 1
-      };
-      return e.gasPrice !== void 0 ? (t.maxFeePerGas = e.gasPrice, t.maxPriorityFeePerGas = e.gasPrice) : (t.maxFeePerGas = e.maxFeePerGas, t.maxPriorityFeePerGas = e.maxPriorityFeePerGas), (await f({
-        evmAccount: n,
-        transaction: t
-      })).signedTransaction;
-    },
-    /**
-     * Signs EIP-712 typed data using CDP's typed data signing functionality.
-     * Handles domain separation and type encoding according to the EIP-712 specification.
-     * For smart accounts, implements replay-safe hash and signature wrapping.
-     *
-     * @param params - The typed data parameters following the EIP-712 specification
-     * @returns The signature as a hex string
-     */
-    async signTypedData(e) {
-      if (s) {
-        const t = await E({
-          smartAccount: n,
-          ownerAddress: r.evmAccountObjects?.[0]?.address,
-          hash: i(e),
-          chainId: Number(e.domain.chainId)
-        });
-        return u({
-          address: p,
-          data: m({
-            abi: v,
-            functionName: "createAccount",
-            args: [[g(r.evmAccountObjects?.[0]?.address)], 0n]
-          }),
-          signature: t.signature
-        });
-      } else {
-        const t = {
-          domain: e.domain,
-          types: {
-            EIP712Domain: A({
-              domain: e.domain
-            }),
-            ...e.types
-          },
-          primaryType: e.primaryType,
-          message: e.message
-        };
-        return (await l({
-          evmAccount: n,
-          typedData: t
-        })).signature;
-      }
-    },
-    /**
-     * Signs a raw message hash using CDP's message signing functionality.
-     *
-     * @param message - The message hash to sign
-     * @returns The signature as a hex string
-     */
-    async sign(e) {
-      return (await o({
-        evmAccount: n,
-        hash: e.hash
-      })).signature;
-    }
-  });
+import "viem";
+const r = ["totp", "sms"], o = (t, e) => {
+  const n = t.mfaMethods[e]?.enrolledAt;
+  return !!n && Date.now() > new Date(n).getTime();
+};
+function i(t) {
+  return t.mfaMethods ? r.filter((e) => o(t, e)) : [];
+}
+function s(t, e) {
+  return e ? o(t, e) : t.mfaMethods ? r.some((n) => o(t, n)) : !1;
 }
 export {
-  _ as toViemAccount
+  i as getEnrolledMfaMethods,
+  s as isEnrolledInMfa
 };

package/dist/esm/index.web36.js

@@ -1,57 +1,51 @@
-class n extends Error {
-  /**
-   * The name of the missing module.
-   */
-  moduleName;
-  /**
-   * The API or feature that requires the missing module.
-   */
-  requiredFor;
-  /**
-   * Creates a new ModuleResolutionError.
-   *
-   * @param moduleName - The name of the missing module.
-   * @param requiredFor - The API or feature that requires the module.
-   * @param message - Optional custom error message.
-   */
-  constructor(r, s, t) {
-    const o = `${s} is not available in this React Native environment. Please ensure ${r} is installed.`;
-    super(t || o), this.name = "ModuleResolutionError", this.moduleName = r, this.requiredFor = s;
+import { APIError as u, ErrorType as l } from "@coinbase/cdp-api-client";
+import { MfaError as m } from "./index.web41.js";
+import { getCoreAuthManager as a } from "./index.web48.js";
+import { hasRegisteredMfaListeners as i, triggerMfaVerification as o } from "./index.web34.js";
+import { isEnrolledInMfa as M, getEnrolledMfaMethods as E } from "./index.web35.js";
+const h = 300, n = () => {
+  const r = a().getUser();
+  return r ? E(r) : [];
+}, s = () => {
+  throw new m(
+    "LISTENER_REQUIRED",
+    "MFA verification is required but no listener is registered."
+  );
+};
+async function A(r) {
+  if (f()) {
+    i() || s();
+    const e = n();
+    await o(e);
   }
-}
-class a extends Error {
-  /**
-   * Creates a new InputValidationError.
-   *
-   * @param message - The validation error message.
-   */
-  constructor(r) {
-    super(r), this.name = "InputValidationError";
+  try {
+    return await r();
+  } catch (e) {
+    if (e instanceof u && e.errorType === l.mfa_required) {
+      i() || s();
+      const t = n();
+      return await o(t), await r();
+    }
+    throw e;
   }
 }
-class i extends Error {
-  /**
-   * Creates a new ValidationError.
-   *
-   * @param message - The validation error message.
-   */
-  constructor(r) {
-    super(r), this.name = "ValidationError";
-  }
+function f() {
+  const r = a().getUser();
+  if (!r || !M(r)) return !1;
+  const t = r?.mfaMethods?.lastVerificationCompletedAt;
+  if (!t) return !0;
+  const d = new Date(t).getTime(), c = h * 1e3;
+  return Date.now() > d + c;
 }
-class l extends Error {
-  /**
-   * Creates a new InternalError.
-   *
-   * @param message - The internal error message.
-   */
-  constructor(r) {
-    super(r), this.name = "InternalError";
-  }
+async function T() {
+  if (!f())
+    return;
+  i() || s();
+  const r = n();
+  await o(r);
 }
 export {
-  a as InputValidationError,
-  l as InternalError,
-  n as ModuleResolutionError,
-  i as ValidationError
+  T as ensureMfaVerified,
+  f as isMfaRequired,
+  A as withMfa
 };

package/dist/esm/index.web37.js

@@ -1,50 +1,25 @@
-import { createStore as c } from "zustand";
-import { subscribeWithSelector as p, persist as d, createJSONStorage as h } from "./index.web63.js";
-import { EventEmitter as f } from "./index.web64.js";
-import "./index.web65.js";
-import "viem";
-import "@coinbase/cdp-api-client";
-import { getPlatformStorage as u } from "./index.web4.js";
-import { createProvider as g } from "./index.web66.js";
-import { onAuthStateChange as l } from "./index.web9.js";
-function U(e) {
-  if (e.chains.length === 0)
-    throw new Error("At least one chain must be configured");
-  if (!e.transports)
-    throw new Error("Transports must be provided");
-  const o = e.chains, i = e.transports;
-  if (o.length === 0)
-    throw new Error("No chains found in configuration");
-  const m = new f(), n = u(), a = {
-    getItem: (t) => n.getItem(t),
-    setItem: (t, r) => n.setItem(t, r),
-    removeItem: (t) => n.removeItem(t)
-  }, s = c()(
-    p(
-      d(
-        (t) => ({
-          chainId: o[0].id,
-          setChainId: (r) => t({ chainId: r }),
-          chains: o,
-          user: null,
-          setUser: (r) => t({ user: r })
-        }),
-        {
-          name: "cdp-provider-store",
-          storage: h(() => a)
-        }
-      )
-    )
-  );
-  return s.persist.rehydrate(), l((t) => {
-    s.getState().setUser(t);
-  }), {
-    provider: g(m, s, {
-      chains: o,
-      transports: i
-    })
-  };
+import { createSolanaKeyExportIframe as e, createEvmKeyExportIframe as o } from "./index.web47.js";
+import { exportSolanaAccount as t, exportEvmAccount as s, sendUserOperation as r, signEvmTypedData as i, signSolanaMessage as c, signEvmMessage as m, sendSolanaTransaction as E, sendEvmTransaction as T, signSolanaTransaction as p, signEvmTransaction as g, signEvmHash as v } from "./index.web9.js";
+const n = {
+  signEvmHash: v,
+  signEvmTransaction: g,
+  signSolanaTransaction: p,
+  sendEvmTransaction: T,
+  sendSolanaTransaction: E,
+  signEvmMessage: m,
+  signSolanaMessage: c,
+  signEvmTypedData: i,
+  sendUserOperation: r,
+  exportEvmAccount: s,
+  exportSolanaAccount: t,
+  createEvmKeyExportIframe: o,
+  createSolanaKeyExportIframe: e
+}, A = Object.keys(n);
+function O(a) {
+  return a in n;
 }
 export {
-  U as createCDPEmbeddedWallet
+  A as MFA_PROTECTED_ACTIONS,
+  n as MFA_PROTECTED_FUNCTIONS,
+  O as isMfaProtectedAction
 };