@coinbase/cdp-core 0.0.107 → 0.0.109

package/dist/esm/index.web87.js

@@ -1,9 +1,135 @@
-function n(e) {
-  if (!/^\+[1-9]\d{1,14}$/.test(e))
+import { hashTypedData as c, serializeErc6492Signature as m, encodeFunctionData as u, pad as g, getTypesForEIP712Domain as p, hashMessage as A } from "viem";
+import { getCurrentUserSync as d } from "./index.web44.js";
+import "@coinbase/cdp-api-client";
+import "./index.web2.js";
+import "./index.web3.js";
+import "jose";
+import "./index.web98.js";
+import { signEvmHash as s } from "./index.web28.js";
+import { signEvmTransaction as h } from "./index.web29.js";
+import { signEvmMessage as l } from "./index.web30.js";
+import { signEvmTypedData as f } from "./index.web31.js";
+import "./index.web93.js";
+import "./index.web99.js";
+import "@solana/web3.js";
+import "bs58";
+import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as y, COINBASE_SMART_WALLET_FACTORY_ABI as v } from "./index.web108.js";
+import { signAndWrapTypedDataForSmartAccount as E } from "./index.web109.js";
+import { toAccount as T } from "./index.web110.js";
+function W(r) {
+  const o = d();
+  if (!o || !o.evmAccountObjects?.length && !o.evmSmartAccountObjects?.length)
     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).`
+      "No accounts found - user must be authenticated and have at least one EVM account or smart account"
     );
+  const i = o.evmAccountObjects?.some((e) => e.address === r) ?? !1, a = o.evmSmartAccountObjects?.some((e) => e.address === r) ?? !1;
+  if (!i && !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 l({
+          evmAccount: r,
+          message: e
+        })).signature;
+      else if ("raw" in e) {
+        const n = A(e);
+        t = (await s({
+          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: c(e),
+          chainId: Number(e.domain.chainId)
+        });
+        return m({
+          address: y,
+          data: u({
+            abi: v,
+            functionName: "createAccount",
+            args: [[g(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 f({
+          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 s({
+        evmAccount: r,
+        hash: e.hash
+      })).signature;
+    }
+  });
 }
 export {
-  n as validatePhoneNumber
+  W as toViemAccount
 };

package/dist/esm/index.web88.js

@@ -1,58 +1,89 @@
-import { createStore as a } from "zustand";
-import { subscribeWithSelector as c, persist as d, createJSONStorage as h } from "./index.web109.js";
-import { EventEmitter as f } from "./index.web110.js";
-import "./index.web111.js";
-import "viem";
-import "@coinbase/cdp-api-client";
-import { getPlatformStorage as u } from "./index.web4.js";
-import { createProvider as g } from "./index.web112.js";
-import { onAuthStateChange as l } from "./index.web25.js";
-import "./index.web2.js";
-import "./index.web3.js";
-import "jose";
-import "./index.web96.js";
-import "./index.web91.js";
-import "./index.web97.js";
-import "@solana/web3.js";
-import "bs58";
-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)
-        }
-      )
-    )
-  );
-  return n.persist.rehydrate(), l((t) => {
-    n.getState().setUser(t);
-  }), {
-    provider: g(m, n, {
-      chains: o,
-      transports: s
-    })
-  };
+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;
+  }
+}
+class a extends Error {
+  /**
+   * Creates a new InputValidationError.
+   *
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "InputValidationError";
+  }
+}
+class i extends Error {
+  /**
+   * Creates a new ValidationError.
+   *
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "ValidationError";
+  }
+}
+class c extends Error {
+  /**
+   * Creates a new InternalError.
+   *
+   * @param message - The internal error message.
+   */
+  constructor(r) {
+    super(r), this.name = "InternalError";
+  }
+}
+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.
+   */
+  constructor(r, e) {
+    super(e), this.name = "MfaError", this.code = r;
+  }
+}
+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;
+  }
 }
 export {
-  j as createCDPEmbeddedWallet
+  a as InputValidationError,
+  c as InternalError,
+  l as MfaError,
+  n as ModuleResolutionError,
+  u as SwapError,
+  i as ValidationError
 };

package/dist/esm/index.web89.js

@@ -1,159 +1,9 @@
-import "viem";
-import "zustand";
-import "@coinbase/cdp-api-client";
-import "./index.web2.js";
-import "./index.web3.js";
-import "jose";
-import "./index.web96.js";
-import { getCurrentUser as u } from "./index.web20.js";
-import "./index.web91.js";
-import "./index.web97.js";
-import "@solana/web3.js";
-import "bs58";
-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 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 g(e, { chains: t }) {
-  const { method: n, params: s } = e;
-  if (typeof n != "string" || n.length === 0)
-    throw new c(
-      r.rpc.invalidParams,
-      "'method' must be a non-empty string."
-    );
-  const a = (s ?? [])[0]?.chainId;
-  if (typeof a == "string" && !t.some((d) => d.id === Number.parseInt(a, 16)))
-    throw new o(
-      r.provider.unsupportedChain,
-      `Chain ${a} not supported - make sure the provider is configured with the correct chains.`
-    );
-  if (s !== void 0 && !Array.isArray(s))
-    throw new c(
-      r.rpc.invalidParams,
-      "'params' must be an array if provided."
-    );
-  if (!p.has(n))
-    throw new o(
-      r.provider.unsupportedMethod,
-      `Method ${e.method} not supported`
-    );
-}
-async function i() {
-  const e = await u();
-  if (!e)
-    throw new o(
-      r.provider.unauthorized,
-      "User not connected"
-    );
-  return e;
-}
-async function C(e) {
-  const t = await i();
-  if (!t.evmAccounts?.includes(e) && !t.evmSmartAccounts?.includes(e))
-    throw new o(
-      r.provider.unauthorized,
-      "Address not owned by user"
-    );
-  return t;
-}
-async function b(e) {
-  const t = await i();
-  if (!t.evmAccounts?.includes(e))
-    throw new o(
-      r.provider.unauthorized,
-      "EOA not owned by user"
-    );
-  return t;
-}
-async function O(e) {
-  const t = await i();
-  if (!t.evmSmartAccounts?.includes(e))
-    throw new o(
-      r.provider.unauthorized,
-      "Smart account not owned by user"
-    );
-  return t;
-}
-async function U() {
-  const e = await i();
-  if (!e.evmSmartAccountObjects?.[0])
-    throw new o(
-      r.provider.unauthorized,
-      "No EVM smart accounts available"
+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).`
     );
-  return e;
 }
 export {
-  o as EIP1193ProviderError,
-  c as RPCRequestError,
-  r as STANDARD_ERROR_CODES,
-  g as validateRequest,
-  i as validateUserConnected,
-  U as validateUserHasEvmSmartAccount,
-  C as validateUserOwnsAddress,
-  b as validateUserOwnsEOA,
-  O as validateUserOwnsSmartAccount
+  n as validatePhoneNumber
 };

package/dist/esm/index.web9.js

@@ -1,120 +1,4 @@
-import { configureCdpApiClient as b, setAuthManager as j, getMfaConfig as k, APIError as u, getProjectConfig as C } from "@coinbase/cdp-api-client";
-import { Analytics as c } from "./index.web2.js";
-import "./index.web3.js";
-import { createAuthManager as v } from "./index.web113.js";
-import { OAuthManager as S } from "./index.web114.js";
-import { MockAuthManager as M } from "./index.web115.js";
-import { MockOAuthManager as P } from "./index.web116.js";
-import { getPlatformServices as g } from "./index.web4.js";
-import { getConfig as a, setCoreAuthManager as m, setCoreOAuthManager as h, setMfaConfig as I, setProjectConfig as A, getCoreAuthManager as w, setConfig as y } from "./index.web72.js";
-import "viem";
-const L = async (t) => {
-  if (!t.projectId)
-    throw new Error("Project ID is required");
-  t.disableAnalytics === void 0 || t.disableAnalytics === !1 ? (c.developerIdentifier = t.projectId, c.isUsingMocks = t.useMock === !0, c.isProduction = !t.basePath || t.basePath === "https://api.cdp.coinbase.com/platform") : c.enabled = !1;
-  let i;
-  try {
-    i = a().projectId !== t.projectId;
-  } catch {
-    i = !0;
-  }
-  if (y(t), a().useMock) {
-    m(new M(a().projectId)), h(new P()), I({
-      projectId: a().projectId,
-      enabled: !1,
-      totpConfig: { enabled: !1 },
-      smsConfig: { enabled: !1 },
-      verificationWindowSeconds: 300,
-      promptEnrollmentOnLogin: !1,
-      requireVerificationOnLogin: !1,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }), A({
-      projectId: a().projectId,
-      name: "Mock Project",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    return;
-  }
-  let s;
-  try {
-    const e = g();
-    s = e.secureStorage ? {
-      getRefreshToken: () => e.secureStorage.getItem("cdp_refresh_token"),
-      setRefreshToken: (o) => e.secureStorage.setItem("cdp_refresh_token", o),
-      removeRefreshToken: () => e.secureStorage.removeItem("cdp_refresh_token")
-    } : (
-      // This is used only in WebKit browsers by virtue of the API
-      {
-        getRefreshToken: () => e.storage.getItem("cdp_refresh_token"),
-        setRefreshToken: (o) => e.storage.setItem("cdp_refresh_token", o),
-        removeRefreshToken: () => e.storage.removeItem("cdp_refresh_token")
-      }
-    );
-  } catch {
-    c.sendSessionRefreshEvent({
-      name: "refresh_token_storage_not_initialized"
-    }), s = void 0;
-  }
-  let r, n, p;
-  try {
-    const e = g();
-    p = e.deviceInfo?.getPlatform?.(), e.attestation && (r = e.attestation, n = e.deviceInfo?.getAppBundleId?.());
-  } catch {
-    r = void 0;
-  }
-  if (b({
-    debugging: a().debugging,
-    basePath: a().basePath,
-    refreshTokenStorage: s,
-    platform: p,
-    appAttestation: r && {
-      isEnabled: () => r.isEnabled,
-      appIdentifier: n,
-      generateAssertion: r.generateAssertion.bind(r)
-    }
-  }), i) {
-    const e = new S();
-    h(e);
-    const o = v(a().projectId);
-    m(o), j(o);
-  }
-  const [, d, f] = await Promise.allSettled([
-    w().ensureInitialized(),
-    (async () => {
-      try {
-        return await k(t.projectId);
-      } catch (e) {
-        return (!(e instanceof u) || e.statusCode !== 404) && console.warn("Failed to get MFA config", e), null;
-      }
-    })(),
-    (async () => {
-      try {
-        return await C(t.projectId);
-      } catch (e) {
-        return (!(e instanceof u) || e.statusCode !== 404) && console.warn("Failed to get project config", e), null;
-      }
-    })()
-  ]);
-  if (d.status === "fulfilled" && d.value && I(d.value), f.status === "fulfilled" && f.value) {
-    const e = f.value;
-    if (A(e), e.appAttestation && r && n) {
-      const o = _(e.appAttestation, n);
-      o !== null && (console.warn(
-        "[Attestation] Project config has attestation enabled for this app, but no attestation provider is registered. Install @coinbase/cdp-app-attest and add `import '@coinbase/cdp-app-attest'` to your app's entry point."
-      ), r.isEnabled = !0, r.cloudProjectNumber = o.cloudProjectNumber, r.initialize().catch((l) => {
-        console.error(
-          "[Attestation] Background initialization failed:",
-          l instanceof Error ? l.message : String(l)
-        );
-      }));
-    }
-  }
-}, _ = (t, i) => {
-  const s = t.android?.find((n) => n.identifier === i);
-  return s ? { cloudProjectNumber: s.googleProjectNumber } : t.ios?.find((n) => n.identifier === i) ? {} : null;
-};
+const o = "0.0.108";
 export {
-  L as initialize
+  o as VERSION
 };