@coinbase/cdp-core 0.0.122 → 0.0.124

package/dist/esm/index.web98.js

@@ -1,108 +1,135 @@
-import { Analytics as u } from "./index.web2.js";
-import "./index.web3.js";
-import { getCurrentUserSync as b } from "./index.web44.js";
+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.web45.js";
 import "@coinbase/cdp-api-client";
+import "./index.web2.js";
+import "./index.web3.js";
 import "jose";
-import "viem";
-import "./index.web103.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.web86.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.web97.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.web96.js";
+import "./index.web110.js";
+import { signEvmHash as i } from "./index.web29.js";
+import { signEvmTransaction as h } from "./index.web30.js";
+import { signEvmMessage as f } from "./index.web31.js";
+import { signEvmTypedData as y } from "./index.web32.js";
 import "./index.web104.js";
+import "./index.web111.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;
-        }
-        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;
-        }
+import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as v, COINBASE_SMART_WALLET_FACTORY_ABI as w } from "./index.web121.js";
+import { signAndWrapTypedDataForSmartAccount as E } from "./index.web122.js";
+import { toAccount as T } from "./index.web123.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"
+    );
+  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;
       }
-  };
-  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
-      });
+    /**
+     * 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;
     }
-  };
-}
-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
+  U as toViemAccount
 };

package/dist/esm/index.web99.js

@@ -1,45 +1,91 @@
-import { getTransactionEncoder as m, getTransactionDecoder as u, address as p } from "@solana/kit";
-import { getCurrentUserSync as f } from "./index.web44.js";
-import "@coinbase/cdp-api-client";
-import "./index.web2.js";
-import "./index.web3.js";
-import "jose";
-import "viem";
-import "./index.web103.js";
-import "./index.web97.js";
-import { signSolanaTransaction as g } from "./index.web32.js";
-import "./index.web104.js";
-import "@solana/web3.js";
-import "bs58";
-import { encodeBase64 as l, decodeBase64 as T } from "./index.web101.js";
-function N(o) {
-  const t = f();
-  if (!t || !t.solanaAccountObjects?.length)
-    throw new Error(
-      "No accounts found. User must be authenticated and have at least one Solana account"
-    );
-  const e = m(), a = u();
-  return {
-    address: p(o),
-    signTransactions: async (c, h) => {
-      const n = [];
-      for (const i of c) {
-        const s = new Uint8Array(e.encode(i)), { signedTransaction: d } = await g({
-          solanaAccount: o,
-          transaction: l(s)
-        }), r = a.decode(T(d)).signatures[o];
-        if (!r)
-          throw new Error("Wallet did not return a signature for the selected account.");
-        n.push(
-          Object.freeze({
-            [o]: r
-          })
-        );
-      }
-      return n;
-    }
-  };
+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.
+   * @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;
+  }
+}
+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 {
-  N as toTransactionSigner
+  a as InputValidationError,
+  c as InternalError,
+  l as MfaError,
+  n as ModuleResolutionError,
+  u as SwapError,
+  i as ValidationError
 };