@coinbase/cdp-core 0.0.51 → 0.0.52

package/dist/web/index.web147.js

@@ -0,0 +1,30 @@
+import { JOSENotSupported as r } from "./index.web45.js";
+const S = (e, s) => {
+  const a = `SHA-${e.slice(-3)}`;
+  switch (e) {
+    case "HS256":
+    case "HS384":
+    case "HS512":
+      return { hash: a, name: "HMAC" };
+    case "PS256":
+    case "PS384":
+    case "PS512":
+      return { hash: a, name: "RSA-PSS", saltLength: parseInt(e.slice(-3), 10) >> 3 };
+    case "RS256":
+    case "RS384":
+    case "RS512":
+      return { hash: a, name: "RSASSA-PKCS1-v1_5" };
+    case "ES256":
+    case "ES384":
+    case "ES512":
+      return { hash: a, name: "ECDSA", namedCurve: s.namedCurve };
+    case "Ed25519":
+    case "EdDSA":
+      return { name: "Ed25519" };
+    default:
+      throw new r(`alg ${e} is not supported either by JOSE or your javascript runtime`);
+  }
+};
+export {
+  S as default
+};

package/dist/web/index.web148.js

@@ -0,0 +1,10 @@
+const o = (t, r) => {
+  if (t.startsWith("RS") || t.startsWith("PS")) {
+    const { modulusLength: e } = r.algorithm;
+    if (typeof e != "number" || e < 2048)
+      throw new TypeError(`${t} requires key modulusLength to be 2048 bits or larger`);
+  }
+};
+export {
+  o as default
+};

package/dist/web/index.web149.js

@@ -0,0 +1,13 @@
+import { checkSigCryptoKey as i } from "./index.web155.js";
+import o from "./index.web150.js";
+const s = async (t, r, e) => {
+  if (r instanceof Uint8Array) {
+    if (!t.startsWith("HS"))
+      throw new TypeError(o(r, "CryptoKey", "KeyObject", "JSON Web Key"));
+    return crypto.subtle.importKey("raw", r, { hash: `SHA-${t.slice(-3)}`, name: "HMAC" }, !1, [e]);
+  }
+  return i(r, t, e), r;
+};
+export {
+  s as default
+};

package/dist/web/index.web150.js

@@ -0,0 +1,15 @@
+function i(n, e, ...o) {
+  if (o = o.filter(Boolean), o.length > 2) {
+    const f = o.pop();
+    n += `one of type ${o.join(", ")}, or ${f}.`;
+  } else o.length === 2 ? n += `one of type ${o[0]} or ${o[1]}.` : n += `of type ${o[0]}.`;
+  return e == null ? n += ` Received ${e}` : typeof e == "function" && e.name ? n += ` Received function ${e.name}` : typeof e == "object" && e != null && e.constructor?.name && (n += ` Received an instance of ${e.constructor.name}`), n;
+}
+const r = (n, ...e) => i("Key must be ", n, ...e);
+function t(n, e, ...o) {
+  return i(`Key for the ${n} algorithm must be `, e, ...o);
+}
+export {
+  r as default,
+  t as withAlg
+};

package/dist/web/index.web151.js

@@ -0,0 +1,12 @@
+function e(t) {
+  return t?.[Symbol.toStringTag] === "CryptoKey";
+}
+function r(t) {
+  return t?.[Symbol.toStringTag] === "KeyObject";
+}
+const n = (t) => e(t) || r(t);
+export {
+  n as default,
+  e as isCryptoKey,
+  r as isKeyObject
+};

package/dist/web/index.web152.js

@@ -0,0 +1,19 @@
+import n from "./index.web98.js";
+function r(t) {
+  return n(t) && typeof t.kty == "string";
+}
+function o(t) {
+  return t.kty !== "oct" && typeof t.d == "string";
+}
+function e(t) {
+  return t.kty !== "oct" && typeof t.d > "u";
+}
+function c(t) {
+  return t.kty === "oct" && typeof t.k == "string";
+}
+export {
+  r as isJWK,
+  o as isPrivateJWK,
+  e as isPublicJWK,
+  c as isSecretJWK
+};

package/dist/web/index.web153.js

@@ -0,0 +1,83 @@
+import { JOSENotSupported as s } from "./index.web45.js";
+function n(e) {
+  let a, r;
+  switch (e.kty) {
+    case "RSA": {
+      switch (e.alg) {
+        case "PS256":
+        case "PS384":
+        case "PS512":
+          a = { name: "RSA-PSS", hash: `SHA-${e.alg.slice(-3)}` }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "RS256":
+        case "RS384":
+        case "RS512":
+          a = { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${e.alg.slice(-3)}` }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "RSA-OAEP":
+        case "RSA-OAEP-256":
+        case "RSA-OAEP-384":
+        case "RSA-OAEP-512":
+          a = {
+            name: "RSA-OAEP",
+            hash: `SHA-${parseInt(e.alg.slice(-3), 10) || 1}`
+          }, r = e.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    case "EC": {
+      switch (e.alg) {
+        case "ES256":
+          a = { name: "ECDSA", namedCurve: "P-256" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ES384":
+          a = { name: "ECDSA", namedCurve: "P-384" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ES512":
+          a = { name: "ECDSA", namedCurve: "P-521" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ECDH-ES":
+        case "ECDH-ES+A128KW":
+        case "ECDH-ES+A192KW":
+        case "ECDH-ES+A256KW":
+          a = { name: "ECDH", namedCurve: e.crv }, r = e.d ? ["deriveBits"] : [];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    case "OKP": {
+      switch (e.alg) {
+        case "Ed25519":
+        case "EdDSA":
+          a = { name: "Ed25519" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ECDH-ES":
+        case "ECDH-ES+A128KW":
+        case "ECDH-ES+A192KW":
+        case "ECDH-ES+A256KW":
+          a = { name: e.crv }, r = e.d ? ["deriveBits"] : [];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    default:
+      throw new s('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
+  }
+  return { algorithm: a, keyUsages: r };
+}
+const i = async (e) => {
+  if (!e.alg)
+    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
+  const { algorithm: a, keyUsages: r } = n(e), t = { ...e };
+  return delete t.alg, delete t.use, crypto.subtle.importKey("jwk", t, a, e.ext ?? !e.d, e.key_ops ?? r);
+};
+export {
+  i as default
+};

package/dist/web/index.web154.js

@@ -0,0 +1,17 @@
+import { SizeExceedsPaddingSizeError as a } from "./index.web143.js";
+function o(r, i = {}) {
+  const { dir: n, size: e = 32 } = i;
+  if (e === 0)
+    return r;
+  const t = r.replace("0x", "");
+  if (t.length > e * 2)
+    throw new a({
+      size: Math.ceil(t.length / 2),
+      targetSize: e,
+      type: "Hex"
+    });
+  return `0x${t[n === "right" ? "padEnd" : "padStart"](e * 2, "0")}`;
+}
+export {
+  o as pad
+};

package/dist/web/index.web155.js

@@ -0,0 +1,81 @@
+function r(t, e = "algorithm.name") {
+  return new TypeError(`CryptoKey does not support this operation, its ${e} must be ${t}`);
+}
+function o(t, e) {
+  return t.name === e;
+}
+function c(t) {
+  return parseInt(t.name.slice(4), 10);
+}
+function h(t) {
+  switch (t) {
+    case "ES256":
+      return "P-256";
+    case "ES384":
+      return "P-384";
+    case "ES512":
+      return "P-521";
+    default:
+      throw new Error("unreachable");
+  }
+}
+function i(t, e) {
+  if (!t.usages.includes(e))
+    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${e}.`);
+}
+function u(t, e, n) {
+  switch (e) {
+    case "HS256":
+    case "HS384":
+    case "HS512": {
+      if (!o(t.algorithm, "HMAC"))
+        throw r("HMAC");
+      const a = parseInt(e.slice(2), 10);
+      if (c(t.algorithm.hash) !== a)
+        throw r(`SHA-${a}`, "algorithm.hash");
+      break;
+    }
+    case "RS256":
+    case "RS384":
+    case "RS512": {
+      if (!o(t.algorithm, "RSASSA-PKCS1-v1_5"))
+        throw r("RSASSA-PKCS1-v1_5");
+      const a = parseInt(e.slice(2), 10);
+      if (c(t.algorithm.hash) !== a)
+        throw r(`SHA-${a}`, "algorithm.hash");
+      break;
+    }
+    case "PS256":
+    case "PS384":
+    case "PS512": {
+      if (!o(t.algorithm, "RSA-PSS"))
+        throw r("RSA-PSS");
+      const a = parseInt(e.slice(2), 10);
+      if (c(t.algorithm.hash) !== a)
+        throw r(`SHA-${a}`, "algorithm.hash");
+      break;
+    }
+    case "Ed25519":
+    case "EdDSA": {
+      if (!o(t.algorithm, "Ed25519"))
+        throw r("Ed25519");
+      break;
+    }
+    case "ES256":
+    case "ES384":
+    case "ES512": {
+      if (!o(t.algorithm, "ECDSA"))
+        throw r("ECDSA");
+      const a = h(e);
+      if (t.algorithm.namedCurve !== a)
+        throw r(a, "algorithm.namedCurve");
+      break;
+    }
+    default:
+      throw new TypeError("CryptoKey does not support this operation");
+  }
+  i(t, n);
+}
+export {
+  u as checkSigCryptoKey
+};

package/dist/web/index.web16.js

@@ -1,121 +1,119 @@
-import { DisconnectedError as u, from as m } from "./index.web41.js";
-import { http as p } from "viem";
-import { createStore as g } from "zustand";
-import { subscribeWithSelector as f, persist as S, createJSONStorage as I } from "./index.web42.js";
-import { validateRequest as w, EIP1193ProviderError as C, STANDARD_ERROR_CODES as b } from "./index.web17.js";
-import { EventEmitter as _ } from "./index.web43.js";
-import { getPlatformStorage as A } from "./index.web2.js";
+import { hashTypedData as i, serializeErc6492Signature as c, encodeFunctionData as u, pad as m, getTypesForEIP712Domain as g } from "viem";
+import { getCurrentUser as A, signEvmHash as l, signEvmTypedData as d, signEvmTransaction as f, signEvmMessage as h } from "./index.web6.js";
 import "@coinbase/cdp-api-client";
-import { handleGetCapabilities as v, handleGetCallsStatus as D, handleSendCalls as E, handleChainId as P, handleSignTypedData as R, handleEthSign as y, handleSwitchEthereumChain as T, handleDisconnect as q, handleSendTransaction as N, handlePersonalSign as O, handleRequestAccounts as G, handleAccounts as L } from "./index.web44.js";
-import { onAuthStateChange as M } from "./index.web6.js";
-import { baseSepolia as h } from "./index.web45.js";
-function W(r, n, s) {
-  n.subscribe(
-    (e) => e.chainId,
-    (e, t) => {
-      e !== t && r.emit("chainChanged", e);
-    }
-  ), n.subscribe(
-    (e) => e.user,
-    (e, t) => {
-      if (!(e?.userId === t?.userId && e?.evmAccounts?.length === t?.evmAccounts?.length)) {
-        if (!e && t) {
-          r.emit("disconnect", new u());
-          return;
-        }
-        if (e && e.evmAccounts?.length && (!t || t.evmAccounts?.length === 0)) {
-          const a = n.getState().chainId;
-          r.emit("connect", { chainId: a });
-          return;
-        }
-      }
-    }
-  );
-  const { chainId: i, setChainId: o } = n.getState(), d = i || s.chains[0].id;
-  return i || o(d), m({
-    request: async (e) => {
-      w(e, s);
-      const t = e;
-      switch (t.method) {
-        case "eth_accounts":
-          return L();
-        case "eth_requestAccounts":
-          return G(r, n);
-        case "personal_sign":
-          return O(t.params);
-        case "eth_sendTransaction":
-          return N(t.params, n, s.transports);
-        case "wallet_disconnect":
-          return q();
-        case "wallet_switchEthereumChain":
-          return T(t.params, n);
-        case "eth_sign":
-          return y(t.params);
-        case "eth_signTypedData_v4":
-          return R(t.params);
-        case "eth_chainId":
-          return P(n);
-        case "wallet_sendCalls":
-          return E(t.params, n);
-        case "wallet_getCallsStatus":
-          return D(t.params, n);
-        case "wallet_getCapabilities":
-          return v();
-        // Catch-all for any unknown method
-        default:
-          throw new C(
-            b.provider.unsupportedMethod,
-            `Method ${t.method} not supported`
-          );
+import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as y, COINBASE_SMART_WALLET_FACTORY_ABI as p } from "./index.web34.js";
+import { signAndWrapTypedDataForSmartAccount as v } from "./index.web35.js";
+import { toAccount as w } from "./index.web36.js";
+async function I(n) {
+  const r = await A();
+  if (!r || !r.evmAccounts?.length && !r.evmSmartAccounts?.length)
+    throw new Error(
+      "No accounts found - user must be authenticated and have at least one EVM account or smart account"
+    );
+  const s = r.evmAccounts?.includes(n) ?? !1, o = r.evmSmartAccounts?.includes(n) ?? !1;
+  if (!s && !o)
+    throw new Error(`Cannot sign for address ${n} - not authorized for this account`);
+  return w({
+    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 = e;
+      else if ("raw" in e)
+        typeof e.raw == "string" ? t = e.raw : t = new TextDecoder().decode(e.raw);
+      else
+        throw new Error("Unsupported message format");
+      return (await h({
+        evmAccount: n,
+        message: t
+      })).signature;
+    },
+    /**
+     * 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 (o) {
+        const t = await v({
+          smartAccount: n,
+          ownerAddress: r.evmAccounts?.[0],
+          hash: i(e),
+          chainId: Number(e.domain.chainId)
+        });
+        return c({
+          address: y,
+          data: u({
+            abi: p,
+            functionName: "createAccount",
+            args: [[m(r.evmAccounts?.[0])], 0n]
+          }),
+          signature: t.signature
+        });
+      } else {
+        const t = {
+          domain: e.domain,
+          types: {
+            EIP712Domain: g({
+              domain: e.domain
+            }),
+            ...e.types
+          },
+          primaryType: e.primaryType,
+          message: e.message
+        };
+        return (await d({
+          evmAccount: n,
+          typedData: t
+        })).signature;
       }
     },
-    // Event emitter methods - only the ones required by the interface
-    on: r.on.bind(r),
-    removeListener: r.removeListener.bind(r)
+    /**
+     * 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 l({
+        evmAccount: n,
+        hash: e.hash
+      })).signature;
+    }
   });
 }
-const l = {
-  chains: [h],
-  transports: {
-    [h.id]: p()
-  }
-};
-function V(r) {
-  if (r?.chains.length === 0)
-    throw new Error("At least one chain must be configured");
-  const n = r?.chains ?? l.chains, s = r?.transports ?? l.transports;
-  if (n.length === 0)
-    throw new Error("No chains found in configuration");
-  const i = new _(), o = A(), d = {
-    getItem: (t) => o.getItem(t),
-    setItem: (t, a) => o.setItem(t, a),
-    removeItem: (t) => o.removeItem(t)
-  }, c = g()(
-    f(
-      S(
-        (t) => ({
-          chainId: n[0].id,
-          setChainId: (a) => t({ chainId: a }),
-          chains: n,
-          user: null,
-          setUser: (a) => t({ user: a })
-        }),
-        {
-          name: "cdp-provider-store",
-          storage: I(() => d)
-        }
-      )
-    )
-  );
-  return c.persist.rehydrate(), M((t) => {
-    c.getState().setUser(t);
-  }), {
-    provider: W(i, c, {
-      chains: n,
-      transports: s
-    })
-  };
-}
 export {
-  V as createCDPEmbeddedWallet
+  I as toViemAccount
 };