@coinbase/cdp-core 0.0.85 → 0.0.87

package/dist/esm/index.web67.js

@@ -1,28 +1,21 @@
-import { InvalidAddressError as s } from "./index.web111.js";
-import { isAddress as a } from "./index.web90.js";
-function r(n) {
-  if (typeof n == "string") {
-    if (!a(n, { strict: !1 }))
-      throw new s({ address: n });
-    return {
-      address: n,
-      type: "json-rpc"
-    };
+import { APIError as c, ErrorType as u, HttpErrorType as E, OAuth2ProviderType as a, SendEvmTransactionWithEndUserAccountBodyNetwork as d, SendSolanaTransactionWithEndUserAccountBodyNetwork as p } from "@coinbase/cdp-api-client";
+import "viem";
+class e extends Error {
+  /**
+   * Creates a new CustomAuthError.
+   *
+   * @param message - The error message.
+   */
+  constructor(r) {
+    super(r), this.name = "CustomAuthError";
   }
-  if (!a(n.address, { strict: !1 }))
-    throw new s({ address: n.address });
-  return {
-    address: n.address,
-    nonceManager: n.nonceManager,
-    sign: n.sign,
-    signAuthorization: n.signAuthorization,
-    signMessage: n.signMessage,
-    signTransaction: n.signTransaction,
-    signTypedData: n.signTypedData,
-    source: "custom",
-    type: "local"
-  };
 }
 export {
-  r as toAccount
+  c as APIError,
+  e as CustomAuthError,
+  u as ErrorType,
+  E as HttpErrorType,
+  a as OAuth2ProviderType,
+  d as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  p as SendSolanaTransactionWithEndUserAccountBodyNetwork
 };

package/dist/esm/index.web68.js

@@ -1,162 +1,135 @@
-const H = (m) => (h, n, r) => {
-  const s = r.subscribe;
-  return r.subscribe = (c, i, a) => {
-    let l = c;
-    if (i) {
-      const g = a?.equalityFn || Object.is;
-      let v = c(r.getState());
-      l = (f) => {
-        const u = c(f);
-        if (!g(v, u)) {
-          const y = v;
-          i(v = u, y);
-        }
-      }, a?.fireImmediately && i(v, v);
-    }
-    return s(l);
-  }, m(h, n, r);
-}, R = H;
-function F(m, h) {
-  let n;
-  try {
-    n = m();
-  } catch {
-    return;
-  }
-  return {
-    getItem: (s) => {
-      var e;
-      const c = (a) => a === null ? null : JSON.parse(a, void 0), i = (e = n.getItem(s)) != null ? e : null;
-      return i instanceof Promise ? i.then(c) : c(i);
-    },
-    setItem: (s, e) => n.setItem(s, JSON.stringify(e, void 0)),
-    removeItem: (s) => n.removeItem(s)
-  };
-}
-const p = (m) => (h) => {
-  try {
-    const n = m(h);
-    return n instanceof Promise ? n : {
-      then(r) {
-        return p(r)(n);
-      },
-      catch(r) {
-        return this;
-      }
-    };
-  } catch (n) {
-    return {
-      then(r) {
-        return this;
-      },
-      catch(r) {
-        return p(r)(n);
-      }
-    };
-  }
-}, O = (m, h) => (n, r, s) => {
-  let e = {
-    storage: F(() => localStorage),
-    partialize: (t) => t,
-    version: 0,
-    merge: (t, S) => ({
-      ...S,
-      ...t
-    }),
-    ...h
-  }, c = !1;
-  const i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
-  let l = e.storage;
-  if (!l)
-    return m(
-      (...t) => {
-        console.warn(
-          `[zustand persist middleware] Unable to update item '${e.name}', the given storage is currently unavailable.`
-        ), n(...t);
-      },
-      r,
-      s
+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.web39.js";
+import "@coinbase/cdp-api-client";
+import "./index.web2.js";
+import "./index.web3.js";
+import "jose";
+import "./index.web84.js";
+import { signEvmHash as s } from "./index.web24.js";
+import { signEvmTransaction as h } from "./index.web25.js";
+import { signEvmMessage as l } from "./index.web26.js";
+import { signEvmTypedData as f } from "./index.web27.js";
+import "./index.web74.js";
+import "./index.web85.js";
+import "@solana/web3.js";
+import "bs58";
+import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as y, COINBASE_SMART_WALLET_FACTORY_ABI as v } from "./index.web86.js";
+import { signAndWrapTypedDataForSmartAccount as E } from "./index.web87.js";
+import { toAccount as T } from "./index.web88.js";
+function W(r) {
+  const o = d();
+  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"
     );
-  const g = () => {
-    const t = e.partialize({ ...r() });
-    return l.setItem(e.name, {
-      state: t,
-      version: e.version
-    });
-  }, v = s.setState;
-  s.setState = (t, S) => {
-    v(t, S), g();
-  };
-  const f = m(
-    (...t) => {
-      n(...t), g();
+  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;
     },
-    r,
-    s
-  );
-  s.getInitialState = () => f;
-  let u;
-  const y = () => {
-    var t, S;
-    if (!l) return;
-    c = !1, i.forEach((o) => {
-      var d;
-      return o((d = r()) != null ? d : f);
-    });
-    const b = ((S = e.onRehydrateStorage) == null ? void 0 : S.call(e, (t = r()) != null ? t : f)) || void 0;
-    return p(l.getItem.bind(l))(e.name).then((o) => {
-      if (o)
-        if (typeof o.version == "number" && o.version !== e.version) {
-          if (e.migrate) {
-            const d = e.migrate(
-              o.state,
-              o.version
-            );
-            return d instanceof Promise ? d.then((I) => [!0, I]) : [!0, d];
-          }
-          console.error(
-            "State loaded from storage couldn't be migrated since no migrate function was provided"
-          );
-        } else
-          return [!1, o.state];
-      return [!1, void 0];
-    }).then((o) => {
-      var d;
-      const [I, _] = o;
-      if (u = e.merge(
-        _,
-        (d = r()) != null ? d : f
-      ), n(u, !0), I)
-        return g();
-    }).then(() => {
-      b?.(u, void 0), u = r(), c = !0, a.forEach((o) => o(u));
-    }).catch((o) => {
-      b?.(void 0, o);
-    });
-  };
-  return s.persist = {
-    setOptions: (t) => {
-      e = {
-        ...e,
-        ...t
-      }, t.storage && (l = t.storage);
+    /**
+     * 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;
     },
-    clearStorage: () => {
-      l?.removeItem(e.name);
+    /**
+     * 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;
+      }
     },
-    getOptions: () => e,
-    rehydrate: () => y(),
-    hasHydrated: () => c,
-    onHydrate: (t) => (i.add(t), () => {
-      i.delete(t);
-    }),
-    onFinishHydration: (t) => (a.add(t), () => {
-      a.delete(t);
-    })
-  }, e.skipHydration || y(), u || f;
-}, w = O;
+    /**
+     * 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 {
-  F as createJSONStorage,
-  w as persist,
-  R as subscribeWithSelector
+  W as toViemAccount
 };

package/dist/esm/index.web69.js

@@ -1,50 +1,73 @@
-class n {
-  events = {};
+class n extends Error {
   /**
-   * Add an event listener.
+   * 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;
+  }
+}
+class a extends Error {
+  /**
+   * Creates a new InputValidationError.
    *
-   * @param event - The name of the event to listen for.
-   * @param listener - The function to call when the event is emitted.
+   * @param message - The validation error message.
    */
-  on(e, s) {
-    this.events[e] || (this.events[e] = []), this.events[e].push(s);
+  constructor(r) {
+    super(r), this.name = "InputValidationError";
   }
+}
+class i extends Error {
   /**
-   * Remove an event listener.
+   * Creates a new ValidationError.
    *
-   * @param event - The name of the event to remove the listener from.
-   * @param listener - The function to remove from the event listeners.
-   */
-  removeListener(e, s) {
-    if (!this.events[e])
-      return;
-    const t = this.events[e].indexOf(s);
-    t > -1 && this.events[e].splice(t, 1);
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "ValidationError";
   }
+}
+class l extends Error {
   /**
-   * Emit an event.
+   * Creates a new InternalError.
    *
-   * @param event - The name of the event to emit.
-   * @param args - The arguments to pass to the event listeners.
-   */
-  emit(e, ...s) {
-    this.events[e] && this.events[e].forEach((t) => {
-      try {
-        t(...s);
-      } catch (i) {
-        console.error(`Error in event listener for ${e}:`, i);
-      }
-    });
+   * @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;
   /**
-   * Remove all listeners for an event.
+   * Creates a new MfaError.
    *
-   * @param event - The name of the event to remove all listeners from. If not provided, removes all listeners for all events.
+   * @param code - The error code identifying the type of MFA error.
+   * @param message - The error message.
    */
-  removeAllListeners(e) {
-    e ? delete this.events[e] : this.events = {};
+  constructor(r, s) {
+    super(s), this.name = "MfaError", this.code = r;
   }
 }
 export {
-  n as EventEmitter
+  a as InputValidationError,
+  l as InternalError,
+  u as MfaError,
+  n as ModuleResolutionError,
+  i as ValidationError
 };

package/dist/esm/index.web70.js

@@ -1,27 +1,9 @@
-import { Analytics as E } from "./index.web2.js";
-import "./index.web3.js";
-import { VERSION as r } from "./index.web8.js";
-import "./index.web50.js";
-import { APIError as c, ErrorType as P, HttpErrorType as U, OAuth2ProviderType as F, SendEvmTransactionWithEndUserAccountBodyNetwork as I, SendSolanaTransactionWithEndUserAccountBodyNetwork as d } from "@coinbase/cdp-api-client";
-import "@solana/web3.js";
-import "bs58";
-import "jose";
-import "viem";
-import "./index.web59.js";
-import { DEFAULT_SECURE_IFRAME_BASE_PATH as y, DEFAULT_SECURE_IFRAME_THEME as M, SECURE_IFRAME_EVENT_TYPE as N, SECURE_IFRAME_EVENT_TYPE_PREFIX as C, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as V } from "./index.web46.js";
-import "@solana/kit";
-import "zustand";
-E.registerPackageVersion("core", r);
+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 {
-  c as APIError,
-  y as DEFAULT_SECURE_IFRAME_BASE_PATH,
-  M as DEFAULT_SECURE_IFRAME_THEME,
-  P as ErrorType,
-  U as HttpErrorType,
-  F as OAuth2ProviderType,
-  N as SECURE_IFRAME_EVENT_TYPE,
-  C as SECURE_IFRAME_EVENT_TYPE_PREFIX,
-  V as SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE,
-  I as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  d as SendSolanaTransactionWithEndUserAccountBodyNetwork
+  n as validatePhoneNumber
 };

package/dist/esm/index.web71.js

@@ -1,75 +1,58 @@
-import { DisconnectedError as l, from as d } from "./index.web79.js";
-import { validateRequest as h, EIP1193ProviderError as m, STANDARD_ERROR_CODES as _ } from "./index.web44.js";
-import { createEOAHandlers as p } from "./index.web80.js";
-import { createSmartAccountHandlers as g } from "./index.web81.js";
+import { createStore as a } from "zustand";
+import { subscribeWithSelector as c, persist as d, createJSONStorage as h } from "./index.web89.js";
+import { EventEmitter as f } from "./index.web90.js";
+import "./index.web91.js";
 import "viem";
-import "zustand";
 import "@coinbase/cdp-api-client";
-function v(c, a, r) {
-  a.subscribe(
-    (e) => e.chainId,
-    (e, t) => {
-      e !== t && c.emit("chainChanged", e);
-    }
-  ), a.subscribe(
-    (e) => e.user,
-    (e, t) => {
-      if (!(e?.userId === t?.userId && e?.evmAccounts?.length === t?.evmAccounts?.length)) {
-        if (!e && t) {
-          c.emit("disconnect", new l());
-          return;
+import { getPlatformStorage as u } from "./index.web4.js";
+import { createProvider as g } from "./index.web92.js";
+import { onAuthStateChange as l } from "./index.web22.js";
+import "./index.web2.js";
+import "./index.web3.js";
+import "jose";
+import "./index.web84.js";
+import "./index.web74.js";
+import "./index.web85.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)
         }
-        if (e && e.evmAccounts?.length && (!t || t.evmAccounts?.length === 0)) {
-          const s = a.getState().chainId;
-          c.emit("connect", { chainId: s });
-          return;
-        }
-      }
-    }
+      )
+    )
   );
-  const { chainId: i, setChainId: o } = a.getState(), u = i || r.chains[0].id;
-  return i || o(u), d({
-    request: async (e) => {
-      h(e, r);
-      const t = e, s = a.getState().user, n = !!(s?.evmSmartAccounts && s.evmSmartAccounts.length > 0) ? g() : p();
-      switch (t.method) {
-        case "eth_accounts":
-          return n.eth_accounts();
-        case "eth_requestAccounts":
-          return n.eth_requestAccounts(c, a);
-        case "personal_sign":
-          return n.personal_sign(t.params, a);
-        case "eth_sendTransaction":
-          return n.eth_sendTransaction(t.params, a, r.transports);
-        case "wallet_disconnect":
-          return n.wallet_disconnect();
-        case "wallet_switchEthereumChain":
-          return n.wallet_switchEthereumChain(t.params, a);
-        case "eth_sign":
-          return n.eth_sign(t.params, a);
-        case "eth_signTypedData_v4":
-          return n.eth_signTypedData_v4(t.params, a);
-        case "eth_chainId":
-          return n.eth_chainId(a);
-        case "wallet_sendCalls":
-          return n.wallet_sendCalls(t.params, a);
-        case "wallet_getCallsStatus":
-          return n.wallet_getCallsStatus(t.params, a);
-        case "wallet_getCapabilities":
-          return n.wallet_getCapabilities();
-        // Catch-all for any unknown method
-        default:
-          throw new m(
-            _.provider.unsupportedMethod,
-            `Method ${t.method} not supported`
-          );
-      }
-    },
-    // Event emitter methods - only the ones required by the interface
-    on: c.on.bind(c),
-    removeListener: c.removeListener.bind(c)
-  });
+  return n.persist.rehydrate(), l((t) => {
+    n.getState().setUser(t);
+  }), {
+    provider: g(m, n, {
+      chains: o,
+      transports: s
+    })
+  };
 }
 export {
-  v as createProvider
+  j as createCDPEmbeddedWallet
 };