@coinbase/cdp-core 0.0.120 → 0.0.122

package/dist/web/index.web91.js

@@ -1,165 +1,135 @@
-import "viem";
-import "zustand";
+import { hashTypedData as m, serializeErc6492Signature as u, encodeFunctionData as g, pad as d, getTypesForEIP712Domain as p, hashMessage as A } from "viem";
+import { getCurrentUserSync as l } from "./index.web44.js";
 import "@coinbase/cdp-api-client";
 import "./index.web2.js";
 import "./index.web3.js";
 import "jose";
-import "./index.web98.js";
-import { getCurrentUser as u } from "./index.web21.js";
-import "./index.web93.js";
-import "./index.web99.js";
+import "./index.web103.js";
+import { signEvmHash as i } from "./index.web28.js";
+import { signEvmTransaction as h } from "./index.web29.js";
+import { signEvmMessage as f } from "./index.web30.js";
+import { signEvmTypedData as y } from "./index.web31.js";
+import "./index.web97.js";
+import "./index.web104.js";
 import "@solana/web3.js";
 import "bs58";
-const n = {
-  rpc: {
-    invalidInput: -32e3,
-    resourceNotFound: -32001,
-    resourceUnavailable: -32002,
-    transactionRejected: -32003,
-    methodNotSupported: -32004,
-    limitExceeded: -32005,
-    parse: -32700,
-    invalidRequest: -32600,
-    methodNotFound: -32601,
-    invalidParams: -32602,
-    internal: -32603
-  },
-  provider: {
-    userRejectedRequest: 4001,
-    unauthorized: 4100,
-    unsupportedMethod: 4200,
-    disconnected: 4900,
-    chainDisconnected: 4901,
-    unsupportedChain: 4902
-  }
-};
-class s extends Error {
-  /**
-   * The error code from EIP1193ErrorCode enum.
-   */
-  code;
-  /**
-   * Creates a new EIP-1193 Provider error.
-   *
-   * @param code - The error code from EIP1193ErrorCode enum.
-   * @param message - The error message.
-   */
-  constructor(t, r) {
-    super(r), this.code = t;
-  }
-}
-class c extends Error {
-  /**
-   * The error code from RPCErrorCode type.
-   */
-  code;
-  /**
-   * Creates a new RPC Invalid Params error.
-   *
-   * @param code - The error code from RPCErrorCode type.
-   * @param message - The error message.
-   */
-  constructor(t, r) {
-    super(r), this.code = t;
-  }
-}
-const p = /* @__PURE__ */ new Set([
-  "eth_accounts",
-  "eth_requestAccounts",
-  "personal_sign",
-  "eth_sendTransaction",
-  "eth_signTypedData_v4",
-  "eth_chainId",
-  "eth_sign",
-  "wallet_disconnect",
-  "wallet_switchEthereumChain",
-  "wallet_sendCalls",
-  "wallet_getCallsStatus",
-  "wallet_getCapabilities"
-]);
-function O(e, { chains: t }) {
-  const { method: r, params: o } = e;
-  if (typeof r != "string" || r.length === 0)
-    throw new c(
-      n.rpc.invalidParams,
-      "'method' must be a non-empty string."
-    );
-  const a = (o ?? [])[0]?.chainId;
-  if (typeof a == "string" && !t.some((i) => i.id === Number.parseInt(a, 16)))
-    throw new s(
-      n.provider.unsupportedChain,
-      `Chain ${a} not supported - make sure the provider is configured with the correct chains.`
-    );
-  if (o !== void 0 && !Array.isArray(o))
-    throw new c(
-      n.rpc.invalidParams,
-      "'params' must be an array if provided."
-    );
-  if (!p.has(r))
-    throw new s(
-      n.provider.unsupportedMethod,
-      `Method ${e.method} not supported`
-    );
-}
-async function d() {
-  const e = await u();
-  if (!e)
-    throw new s(
-      n.provider.unauthorized,
-      "User not connected"
-    );
-  return e;
-}
-async function S(e) {
-  const t = await d(), r = e.toLowerCase(), o = t.evmAccountObjects?.some(
-    (i) => i.address.toLowerCase() === r
-  ), a = t.evmSmartAccountObjects?.some(
-    (i) => i.address.toLowerCase() === r
-  );
-  if (!o && !a)
-    throw new s(
-      n.provider.unauthorized,
-      "Address not owned by user"
-    );
-  return t;
-}
-async function R(e) {
-  const t = await d(), r = e.toLowerCase();
-  if (!t.evmAccountObjects?.some((o) => o.address.toLowerCase() === r))
-    throw new s(
-      n.provider.unauthorized,
-      "EOA not owned by user"
-    );
-  return t;
-}
-async function g(e) {
-  const t = await d(), r = e.toLowerCase();
-  if (!t.evmSmartAccountObjects?.some(
-    (o) => o.address.toLowerCase() === r
-  ))
-    throw new s(
-      n.provider.unauthorized,
-      "Smart account not owned by user"
-    );
-  return t;
-}
-async function z() {
-  const e = await d();
-  if (!e.evmSmartAccountObjects?.[0])
-    throw new s(
-      n.provider.unauthorized,
-      "No EVM smart accounts available"
+import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as v, COINBASE_SMART_WALLET_FACTORY_ABI as w } from "./index.web114.js";
+import { signAndWrapTypedDataForSmartAccount as E } from "./index.web115.js";
+import { toAccount as T } from "./index.web116.js";
+function U(r) {
+  const o = l();
+  if (!o || !o.evmAccountObjects?.length && !o.evmSmartAccountObjects?.length)
+    throw new Error(
+      "No accounts found - user must be authenticated and have at least one EVM account or smart account"
     );
-  return e;
+  const s = r.toLowerCase(), c = o.evmAccountObjects?.some((e) => e.address.toLowerCase() === s) ?? !1, a = o.evmSmartAccountObjects?.some((e) => e.address.toLowerCase() === s) ?? !1;
+  if (!c && !a)
+    throw new Error(`Cannot sign for address ${r} - not authorized for this account`);
+  return T({
+    address: r,
+    /**
+     * 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 f({
+          evmAccount: r,
+          message: e
+        })).signature;
+      else if ("raw" in e) {
+        const n = A(e);
+        t = (await i({
+          evmAccount: r,
+          hash: n
+        })).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 h({
+        evmAccount: r,
+        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 (a) {
+        const t = await E({
+          smartAccount: r,
+          ownerAddress: o.evmAccountObjects?.[0]?.address,
+          hash: m(e),
+          chainId: Number(e.domain.chainId)
+        });
+        return u({
+          address: v,
+          data: g({
+            abi: w,
+            functionName: "createAccount",
+            args: [[d(o.evmAccountObjects?.[0]?.address)], 0n]
+          }),
+          signature: t.signature
+        });
+      } else {
+        const t = {
+          domain: e.domain,
+          types: {
+            EIP712Domain: p({
+              domain: e.domain
+            }),
+            ...e.types
+          },
+          primaryType: e.primaryType,
+          message: e.message
+        };
+        return (await y({
+          evmAccount: r,
+          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 i({
+        evmAccount: r,
+        hash: e.hash
+      })).signature;
+    }
+  });
 }
 export {
-  s as EIP1193ProviderError,
-  c as RPCRequestError,
-  n as STANDARD_ERROR_CODES,
-  O as validateRequest,
-  d as validateUserConnected,
-  z as validateUserHasEvmSmartAccount,
-  S as validateUserOwnsAddress,
-  R as validateUserOwnsEOA,
-  g as validateUserOwnsSmartAccount
+  U as toViemAccount
 };

package/dist/web/index.web92.js

@@ -1,70 +1,91 @@
-import { InputValidationError as c } from "./index.web88.js";
-import { DEFAULT_SECURE_IFRAME_BASE_PATH as l, DEFAULT_SECURE_IFRAME_THEME as o, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as f, SECURE_IFRAME_EVENT_TYPE_PREFIX as u } from "./index.web93.js";
-function m() {
-  if (!document)
-    throw new Error("Document not found. This function must be called in a browser environment.");
+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, e, o) {
+    const t = `${e} is not available in this React Native environment. Please ensure ${r} is installed.`;
+    super(o || t), this.name = "ModuleResolutionError", this.moduleName = r, this.requiredFor = e;
+  }
 }
-function b(e) {
-  const t = e.basePath || l, n = ["fullWidth"];
-  return e.projectId && n.push(`projectId=${e.projectId.trim()}`), e.label && n.push(`label=${encodeURIComponent(e.label.trim())}`), e.copiedLabel && n.push(`copiedLabel=${encodeURIComponent(e.copiedLabel.trim())}`), e.icon !== !1 && n.push("icon"), e.ejectIcon !== void 0 && n.push(`ejectIcon=${e.ejectIcon}`), e.ejectLabel && n.push(`ejectLabel=${encodeURIComponent(e.ejectLabel.trim())}`), e.ejectingLabel && n.push(`ejectingLabel=${encodeURIComponent(e.ejectingLabel.trim())}`), e.ejectedLabel && n.push(`ejectedLabel=${encodeURIComponent(e.ejectedLabel.trim())}`), `${t}?${n.join("&")}`;
+class a extends Error {
+  /**
+   * Creates a new InputValidationError.
+   *
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "InputValidationError";
+  }
 }
-function h(e, t) {
-  if (!e?.contentWindow || !e?.src) return;
-  const n = E(e.src);
-  n && e.contentWindow.postMessage(t, n);
+class i extends Error {
+  /**
+   * Creates a new ValidationError.
+   *
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "ValidationError";
+  }
 }
-function E(e) {
-  try {
-    return new URL(e).origin;
-  } catch (t) {
-    return console.error("Error parsing iframe origin", t), "";
+class c extends Error {
+  /**
+   * Creates a new InternalError.
+   *
+   * @param message - The internal error message.
+   */
+  constructor(r) {
+    super(r), this.name = "InternalError";
   }
 }
-function p(e) {
-  if (e instanceof HTMLIFrameElement)
-    throw new c(
-      "target cannot be an iframe element. Pass a container element or CSS selector instead."
-    );
-  m();
-  let t;
-  if (typeof e == "string") {
-    const r = document.querySelector(e);
-    if (!r)
-      throw new c(`No element found for selector "${e}".`);
-    if (r instanceof HTMLIFrameElement)
-      throw new c(
-        `Selector "${e}" resolved to an iframe element. Pass a container element or CSS selector instead.`
-      );
-    t = r;
-  } else
-    t = e;
-  const n = document.createElement("iframe");
-  return t.appendChild(n), n;
+class l extends Error {
+  /**
+   * The error code identifying the type of MFA error.
+   */
+  code;
+  /**
+   * Creates a new MfaError.
+   *
+   * @param code - The error code identifying the type of MFA error.
+   * @param message - The error message.
+   * @param options - Additional error options.
+   * @param options.cause - The underlying error this one was mapped from, when there is one.
+   */
+  constructor(r, e, o) {
+    super(e, o), this.name = "MfaError", this.code = r;
+  }
 }
-const d = {
-  lg: 1,
-  // 1em top + 1em bottom
-  md: 0.75,
-  // 0.75em top + 0.75em bottom
-  sm: 0.5,
-  // 0.5em top + 0.5em bottom
-  xs: 0.25
-  // 0.25em top + 0.25em bottom
-};
-function S(e) {
-  const t = e?.buttonSize || o.buttonSize, n = e?.buttonFontSize || o.buttonFontSize, r = 1.5, i = 4, a = d[t] * 2 + r;
-  return Math.ceil(a * n + i);
+class u extends Error {
+  /**
+   * The error code identifying the type of swap failure.
+   */
+  code;
+  /**
+   * Creates a new SwapError.
+   *
+   * @param code - The error code identifying the type of swap failure.
+   * @param message - The error message.
+   */
+  constructor(r, e) {
+    super(e), this.name = "SwapError", this.code = r;
+  }
 }
-const _ = (e) => typeof e == "object" && e !== null && "type" in e && typeof e.type == "string" && !!f[e.type.replace(
-  u,
-  ""
-)];
 export {
-  b as buildKeyExportIframeUrl,
-  S as calculateSecureIframeHeight,
-  p as createIframe,
-  E as getSecureIframeOrigin,
-  _ as isSecureIframeKeyExportMessage,
-  h as sendSecureIframeMessage,
-  m as validateSecureIframeEnvironment
+  a as InputValidationError,
+  c as InternalError,
+  l as MfaError,
+  n as ModuleResolutionError,
+  u as SwapError,
+  i as ValidationError
 };

package/dist/web/index.web93.js

@@ -1,38 +1,9 @@
-const t = "CDP_WEB_SECURE_IFRAME_", E = {
-  INIT: `${t}INIT`,
-  LISTENING: `${t}LISTENING`,
-  STATUS: `${t}STATUS`,
-  THEME: `${t}THEME`
-}, o = {
-  ...E,
-  GET_PRIVATE_KEY: `${t}GET_PRIVATE_KEY`,
-  SHOW_EJECT: `${t}SHOW_EJECT`
-}, f = "https://secure-wallet.cdp.coinbase.com", e = {
-  pageBg: "#ffffff",
-  buttonBg: "#0052ff",
-  buttonBgHover: "#0748d6",
-  buttonBgPressed: "#0b3eae",
-  buttonBgFocus: "#014cec",
-  buttonBorder: "#014cec",
-  buttonBorderHover: "#0748d6",
-  buttonBorderPressed: "#0b3eae",
-  buttonBorderFocus: "#014cec",
-  buttonBorderFocusInset: "#ffffff",
-  buttonText: "#ffffff",
-  buttonTextHover: "#ffffff",
-  buttonTextPressed: "#ffffff",
-  buttonTextFocus: "#ffffff",
-  buttonBorderRadius: 99999,
-  buttonFontSize: 16,
-  buttonFontWeight: 500,
-  buttonSize: "md",
-  fontUrl: "",
-  fontFamily: ""
-};
+function n(e) {
+  if (!/^\+[1-9]\d{1,14}$/.test(e))
+    throw new Error(
+      `Invalid phone number format: "${e}". Phone number must be in E.164 format (e.g., +14155552671). Requirements: starts with +, followed by country code (1-3 digits), then subscriber number. Total length: 1-15 digits (excluding + prefix).`
+    );
+}
 export {
-  f as DEFAULT_SECURE_IFRAME_BASE_PATH,
-  e as DEFAULT_SECURE_IFRAME_THEME,
-  E as SECURE_IFRAME_EVENT_TYPE,
-  t as SECURE_IFRAME_EVENT_TYPE_PREFIX,
-  o as SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE
+  n as validatePhoneNumber
 };

package/dist/web/index.web94.js

@@ -1,108 +1,58 @@
-import { Analytics as u } from "./index.web2.js";
-import "./index.web3.js";
-import { getCurrentUserSync as b } from "./index.web44.js";
+import { createStore as a } from "zustand";
+import { subscribeWithSelector as c, persist as d, createJSONStorage as h } from "./index.web117.js";
+import { EventEmitter as f } from "./index.web118.js";
+import "./index.web119.js";
+import "viem";
 import "@coinbase/cdp-api-client";
+import { getPlatformStorage as u } from "./index.web5.js";
+import { createProvider as g } from "./index.web120.js";
+import { onAuthStateChange as l } from "./index.web26.js";
+import "./index.web2.js";
+import "./index.web3.js";
 import "jose";
-import "viem";
-import "./index.web98.js";
-import { getConfig as S } from "./index.web74.js";
-import { getAccessToken as A } from "./index.web24.js";
-import { getAccessTokenExpiration as j } from "./index.web25.js";
-import { ensureMfaVerified as y } from "./index.web82.js";
-import { DEFAULT_SECURE_IFRAME_BASE_PATH as w, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as n, DEFAULT_SECURE_IFRAME_THEME as k } from "./index.web93.js";
-import { validateSecureIframeEnvironment as g, createIframe as x, calculateSecureIframeHeight as U, buildKeyExportIframeUrl as L, getSecureIframeOrigin as v, isSecureIframeKeyExportMessage as R, sendSecureIframeMessage as l } from "./index.web92.js";
-import "./index.web99.js";
+import "./index.web103.js";
+import "./index.web97.js";
+import "./index.web104.js";
 import "@solana/web3.js";
 import "bs58";
-let c = null;
-const C = async () => (c || (c = A({ forceRefresh: !0 }).finally(() => {
-  c = null;
-})), c);
-async function h(e) {
-  const r = x(e.target), I = U(e.theme), m = S().secureIframeBasePath || w;
-  r.setAttribute("allow", "clipboard-read; clipboard-write"), r.style.border = "none", r.style.display = "none", r.style.height = `${I}px`, r.src = L({ projectId: e.projectId, basePath: m });
-  const d = v(m);
-  let f = !1;
-  const E = () => {
-    f || (f = !0, window.removeEventListener("message", p), r.parentNode && r.parentNode.removeChild(r));
-  }, p = async (a) => {
-    if (a.source !== r.contentWindow || !d || a.origin !== d) return;
-    const i = a.data;
-    if (R(i))
-      switch (i.type) {
-        case n.LISTENING: {
-          try {
-            const t = b();
-            if (!t) {
-              e.onStatusUpdate?.("error", "User not authenticated");
-              return;
-            }
-            const o = await C(), s = await j();
-            l(r, {
-              type: n.GET_PRIVATE_KEY,
-              payload: {
-                address: e.address,
-                type: e.type,
-                authState: {
-                  accessToken: o || "",
-                  expiresAt: s || 0,
-                  user: t
-                },
-                theme: {
-                  ...k,
-                  ...e.theme || {}
-                },
-                config: {
-                  action: e.action,
-                  label: e.label,
-                  copiedLabel: e.copiedLabel,
-                  ejectLabel: e.ejectLabel ?? "Eject wallet",
-                  ejectingLabel: e.ejectingLabel ?? "Ejecting…",
-                  ejectedLabel: e.ejectedLabel ?? "Ejected",
-                  icon: e.icon,
-                  ejectIcon: e.ejectIcon,
-                  fullWidth: e.fullWidth
-                }
-              }
-            });
-          } catch (t) {
-            e.onStatusUpdate?.(
-              "error",
-              t instanceof Error ? "Error requesting private key: " + t.message : "Error requesting private key"
-            );
-          }
-          break;
+function j(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, s = e.transports;
+  if (o.length === 0)
+    throw new Error("No chains found in configuration");
+  const m = new f(), i = u(), p = {
+    getItem: (t) => i.getItem(t),
+    setItem: (t, r) => i.setItem(t, r),
+    removeItem: (t) => i.removeItem(t)
+  }, n = a()(
+    c(
+      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(() => p)
         }
-        case n.STATUS: {
-          const { status: t, message: o, operation: s, errorType: T, correlationId: _ } = i.payload;
-          t === "ready" && (r.style.display = "block"), t === "expired" && (r.style.display = "none", E()), e.onStatusUpdate?.(t, o, { operation: s, errorType: T, correlationId: _ });
-          break;
-        }
-      }
-  };
-  return window.addEventListener("message", p), {
-    iframe: r,
-    cleanup: E,
-    updateTheme: (a) => {
-      l(r, {
-        type: n.THEME,
-        payload: { theme: a }
-      });
-    },
-    showEject: () => {
-      l(r, {
-        type: n.SHOW_EJECT
-      });
-    }
+      )
+    )
+  );
+  return n.persist.rehydrate(), l((t) => {
+    n.getState().setUser(t);
+  }), {
+    provider: g(m, n, {
+      chains: o,
+      transports: s
+    })
   };
 }
-async function Q(e) {
-  return u.sendActionCallEvent({ name: "create_evm_key_export_iframe" }), g(), await y(), h({ ...e, type: "evm" });
-}
-async function Z(e) {
-  return u.sendActionCallEvent({ name: "create_solana_key_export_iframe" }), g(), await y(), h({ ...e, type: "solana" });
-}
 export {
-  Q as createEvmKeyExportIframe,
-  Z as createSolanaKeyExportIframe
+  j as createCDPEmbeddedWallet
 };