@coinbase/cdp-core 0.0.79 → 0.0.80

package/dist/esm/index.web40.js

@@ -1,37 +1,124 @@
-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`
-}, 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: ""
-};
+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.web65.js";
+import { signAndWrapTypedDataForSmartAccount as E } from "./index.web66.js";
+import { toAccount as T } from "./index.web67.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;
+    }
+  });
+}
 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
+  _ as toViemAccount
 };

package/dist/esm/index.web41.js

@@ -1,73 +1,73 @@
-import "./index.web2.js";
-import { useSendHookCallOnce as l } from "./index.web67.js";
-import "./index.web3.js";
-import { getCurrentUserSync as T } from "./index.web13.js";
-import { getAccessToken as g, getAccessTokenExpiration as I } from "./index.web9.js";
-import { DEFAULT_SECURE_IFRAME_BASE_PATH as S, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as s, DEFAULT_SECURE_IFRAME_THEME as h } from "./index.web40.js";
-import { validateSecureIframeEnvironment as f, createIframe as x, calculateSecureIframeHeight as A, buildKeyExportIframeUrl as U, getSecureIframeOrigin as k, isSecureIframeKeyExportMessage as b, sendSecureIframeMessage as E } from "./index.web39.js";
-import { getConfig as w } from "./index.web53.js";
-async function u(t) {
-  const e = x(t.target), y = A(t.theme), c = w().secureIframeBasePath || S;
-  e.setAttribute("allow", "clipboard-read; clipboard-write"), e.style.border = "none", e.style.display = "none", e.style.height = `${y}px`, e.src = U({ ...t, basePath: c });
-  const i = k(c);
-  let m = !1;
-  const p = () => {
-    m || (m = !0, window.removeEventListener("message", d), e.parentNode && e.parentNode.removeChild(e));
-  }, d = async (a) => {
-    if (!i || a.origin !== i) return;
-    const n = a.data;
-    if (b(n))
-      switch (n.type) {
-        case s.LISTENING: {
-          const r = T();
-          if (!r) {
-            t.onStatusUpdate?.("error", "User not authenticated");
-            return;
-          }
-          const o = await g(), _ = await I();
-          E(e, {
-            type: s.GET_PRIVATE_KEY,
-            payload: {
-              address: t.address,
-              type: t.type,
-              authState: {
-                accessToken: o || "",
-                expiresAt: _ || 0,
-                user: r
-              },
-              theme: {
-                ...h,
-                ...t.theme || {}
-              }
-            }
-          });
-          break;
-        }
-        case s.STATUS: {
-          const { status: r, message: o } = n.payload;
-          r === "ready" && (e.style.display = "block"), r === "expired" && (e.style.display = "none", p()), t.onStatusUpdate?.(r, o);
-          break;
-        }
-      }
-  };
-  return window.addEventListener("message", d), {
-    iframe: e,
-    cleanup: p,
-    updateTheme: (a) => {
-      E(e, {
-        type: s.THEME,
-        payload: { theme: a }
-      });
-    }
-  };
+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, o) {
+    const t = `${s} is not available in this React Native environment. Please ensure ${r} is installed.`;
+    super(o || t), this.name = "ModuleResolutionError", this.moduleName = r, this.requiredFor = s;
+  }
 }
-async function N(t) {
-  return l("create_evm_key_export_iframe"), f(), u({ ...t, type: "evm" });
+class a extends Error {
+  /**
+   * Creates a new InputValidationError.
+   *
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "InputValidationError";
+  }
 }
-async function O(t) {
-  return l("create_solana_key_export_iframe"), f(), u({ ...t, type: "solana" });
+class i extends Error {
+  /**
+   * Creates a new ValidationError.
+   *
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "ValidationError";
+  }
+}
+class l extends Error {
+  /**
+   * Creates a new InternalError.
+   *
+   * @param message - The internal error message.
+   */
+  constructor(r) {
+    super(r), this.name = "InternalError";
+  }
+}
+class u 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.
+   */
+  constructor(r, s) {
+    super(s), this.name = "MfaError", this.code = r;
+  }
 }
 export {
-  N as createEvmKeyExportIframe,
-  O as createSolanaKeyExportIframe
+  a as InputValidationError,
+  l as InternalError,
+  u as MfaError,
+  n as ModuleResolutionError,
+  i as ValidationError
 };

package/dist/esm/index.web42.js

@@ -1,34 +1,9 @@
-function a(e) {
-  if (typeof btoa < "u")
-    return btoa(
-      Array.from(e).map((t) => String.fromCharCode(t)).join("")
+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).`
     );
-  const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  let r = "";
-  for (let t = 0; t < e.length; t += 3) {
-    const h = e[t], n = t + 1 < e.length ? e[t + 1] : 0, s = t + 2 < e.length ? e[t + 2] : 0, o = h << 16 | n << 8 | s;
-    r += c.charAt(o >> 18 & 63), r += c.charAt(o >> 12 & 63), r += t + 1 < e.length ? c.charAt(o >> 6 & 63) : "=", r += t + 2 < e.length ? c.charAt(o & 63) : "=";
-  }
-  return r;
-}
-function g(e) {
-  if (typeof atob < "u") {
-    const n = atob(e), s = new Uint8Array(n.length);
-    for (let o = 0; o < n.length; o++)
-      s[o] = n.charCodeAt(o);
-    return s;
-  }
-  const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r = {};
-  for (let n = 0; n < c.length; n++)
-    r[c[n]] = n;
-  const t = e.replace(/[^A-Za-z0-9+/]/g, ""), h = [];
-  for (let n = 0; n < t.length; n += 4) {
-    const s = r[t[n]] || 0, o = r[t[n + 1]] || 0, l = r[t[n + 2]] || 0, f = r[t[n + 3]] || 0, i = s << 18 | o << 12 | l << 6 | f;
-    h.push(i >> 16 & 255), n + 2 < t.length && h.push(i >> 8 & 255), n + 3 < t.length && h.push(i & 255);
-  }
-  return new Uint8Array(h);
 }
 export {
-  g as decodeBase64,
-  a as encodeBase64
+  n as validatePhoneNumber
 };

package/dist/esm/index.web43.js

@@ -1,5 +1,50 @@
-import { __require as r } from "./index.web68.js";
-var f = r();
+import { createStore as c } from "zustand";
+import { subscribeWithSelector as p, persist as d, createJSONStorage as h } from "./index.web68.js";
+import { EventEmitter as f } from "./index.web69.js";
+import "./index.web70.js";
+import "viem";
+import "@coinbase/cdp-api-client";
+import { getPlatformStorage as u } from "./index.web4.js";
+import { createProvider as g } from "./index.web71.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
+    })
+  };
+}
 export {
-  f as b
+  U as createCDPEmbeddedWallet
 };

package/dist/esm/index.web44.js

@@ -1,11 +1,151 @@
-import { AuthManager as r } from "./index.web33.js";
-import { CustomAuthManager as o } from "./index.web45.js";
-import "@coinbase/cdp-api-client";
 import "viem";
-import { getConfig as n } from "./index.web53.js";
-function a(t) {
-  return n().customAuth?.getJwt ? new o(t) : new r(t);
+import "zustand";
+import "@coinbase/cdp-api-client";
+import { getCurrentUser as u } from "./index.web9.js";
+const r = {
+  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 o 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, n) {
+    super(n), 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, n) {
+    super(n), this.code = t;
+  }
+}
+const h = /* @__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 v(e, { chains: t }) {
+  const { method: n, params: a } = e;
+  if (typeof n != "string" || n.length === 0)
+    throw new c(
+      r.rpc.invalidParams,
+      "'method' must be a non-empty string."
+    );
+  const i = (a ?? [])[0]?.chainId;
+  if (typeof i == "string" && !t.some((d) => d.id === Number.parseInt(i, 16)))
+    throw new o(
+      r.provider.unsupportedChain,
+      `Chain ${i} not supported - make sure the provider is configured with the correct chains.`
+    );
+  if (a !== void 0 && !Array.isArray(a))
+    throw new c(
+      r.rpc.invalidParams,
+      "'params' must be an array if provided."
+    );
+  if (!h.has(n))
+    throw new o(
+      r.provider.unsupportedMethod,
+      `Method ${e.method} not supported`
+    );
+}
+async function s() {
+  const e = await u();
+  if (!e)
+    throw new o(
+      r.provider.unauthorized,
+      "User not connected"
+    );
+  return e;
+}
+async function f(e) {
+  const t = await s();
+  if (!t.evmAccounts?.includes(e) && !t.evmSmartAccounts?.includes(e))
+    throw new o(
+      r.provider.unauthorized,
+      "Address not owned by user"
+    );
+  return t;
+}
+async function A(e) {
+  const t = await s();
+  if (!t.evmAccounts?.includes(e))
+    throw new o(
+      r.provider.unauthorized,
+      "EOA not owned by user"
+    );
+  return t;
+}
+async function _(e) {
+  const t = await s();
+  if (!t.evmSmartAccounts?.includes(e))
+    throw new o(
+      r.provider.unauthorized,
+      "Smart account not owned by user"
+    );
+  return t;
+}
+async function y() {
+  const e = await s();
+  if (!e.evmSmartAccountObjects?.[0])
+    throw new o(
+      r.provider.unauthorized,
+      "No EVM smart accounts available"
+    );
+  return e;
 }
 export {
-  a as createAuthManager
+  o as EIP1193ProviderError,
+  c as RPCRequestError,
+  r as STANDARD_ERROR_CODES,
+  v as validateRequest,
+  s as validateUserConnected,
+  y as validateUserHasEvmSmartAccount,
+  f as validateUserOwnsAddress,
+  A as validateUserOwnsEOA,
+  _ as validateUserOwnsSmartAccount
 };