@coinbase/cdp-core 0.0.69 → 0.0.71

package/dist/web/index.web145.js

@@ -1,26 +1,35 @@
-import { hashMessage as e, hexToString as s, bytesToString as c } from "viem";
-import { signAndWrapTypedDataForSmartAccount as d } from "./index.web46.js";
-import { validateUserOwnsSmartAccount as u, EIP1193ProviderError as g, STANDARD_ERROR_CODES as h } from "./index.web25.js";
-async function m(r, o) {
-  const [a, n] = r, i = await u(n);
-  try {
-    const { signature: t } = await d({
-      smartAccount: n,
-      ownerAddress: i.evmAccounts[0],
-      hash: f(a),
-      chainId: o.getState().chainId
+import { maxBytesPerTransaction as y, bytesPerBlob as a, fieldElementsPerBlob as f, bytesPerFieldElement as p } from "./index.web168.js";
+import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index.web100.js";
+import { createCursor as B } from "./index.web88.js";
+import { size as u } from "./index.web83.js";
+import { hexToBytes as x } from "./index.web75.js";
+import { bytesToHex as d } from "./index.web73.js";
+function S(e) {
+  const m = e.to ?? (typeof e.data == "string" ? "hex" : "bytes"), i = typeof e.data == "string" ? x(e.data) : e.data, o = u(i);
+  if (!o)
+    throw new c();
+  if (o > y)
+    throw new h({
+      maxSize: y,
+      size: o
     });
-    return t;
-  } catch (t) {
-    throw new g(
-      h.provider.userRejectedRequest,
-      t instanceof Error ? t.message : "Signing failed"
-    );
+  const s = [];
+  let n = !0, r = 0;
+  for (; n; ) {
+    const t = B(new Uint8Array(a));
+    let l = 0;
+    for (; l < f; ) {
+      const b = i.slice(r, r + (p - 1));
+      if (t.pushByte(0), t.pushBytes(b), b.length < 31) {
+        t.pushByte(128), n = !1;
+        break;
+      }
+      l++, r += 31;
+    }
+    s.push(t);
   }
-}
-function f(r) {
-  return typeof r == "string" ? e(s(r)) : typeof r.raw == "string" ? r.raw : e(c(r.raw));
+  return m === "bytes" ? s.map((t) => t.bytes) : s.map((t) => d(t.bytes));
 }
 export {
-  m as handlePersonalSign
+  S as toBlobs
 };

package/dist/web/index.web146.js

@@ -1,11 +1,9 @@
-import { fromNumber as c } from "./index.web172.js";
-import { validateUserConnected as o } from "./index.web25.js";
-async function m(t, e) {
-  const n = await o();
-  return t.emit("connect", {
-    chainId: c(e.getState().chainId)
-  }), n.evmSmartAccounts || [];
+import { bytesToHex as i } from "./index.web73.js";
+import { sha256 as m } from "./index.web92.js";
+function f(t) {
+  const { commitment: e, version: s = 1 } = t, n = t.to ?? (typeof e == "string" ? "hex" : "bytes"), o = m(e);
+  return o.set([s], 0), n === "bytes" ? o : i(o);
 }
 export {
-  m as handleRequestAccounts
+  f as commitmentToVersionedHash
 };

package/dist/web/index.web147.js

@@ -1,33 +1,23 @@
-import { sendUserOperation as c } from "./index.web6.js";
-import { isChainIdSupportedForCDPUserOps as u, userOperationChainIdToNameMapping as p } from "./index.web38.js";
-import { validateUserHasEvmSmartAccount as d, RPCRequestError as o, STANDARD_ERROR_CODES as s } from "./index.web25.js";
-async function R(r, t) {
-  const [{ calls: n }] = r, i = (await d()).evmSmartAccounts[0], a = t.getState().chainId;
-  if (!u(a))
-    throw new o(
-      s.rpc.invalidParams,
-      "Chain ID is not supported for user operations"
-    );
+import { encoder as t, decoder as o } from "./index.web112.js";
+import { encodeBase64 as c, decodeBase64 as a } from "./index.web169.js";
+function i(r) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(typeof r == "string" ? r : o.decode(r), {
+      alphabet: "base64url"
+    });
+  let e = r;
+  e instanceof Uint8Array && (e = o.decode(e)), e = e.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "");
   try {
-    return (await c({
-      evmSmartAccount: i,
-      calls: m(n),
-      network: p[a]
-    })).userOperationHash;
-  } catch (e) {
-    throw new o(
-      s.rpc.transactionRejected,
-      e instanceof Error ? e.message : "User operation failed"
-    );
+    return a(e);
+  } catch {
+    throw new TypeError("The input to be decoded is not correctly encoded.");
   }
 }
-function m(r) {
-  return r.map((t) => ({
-    to: t.to,
-    data: t.data,
-    value: t.value ? BigInt(t.value) : void 0
-  }));
+function p(r) {
+  let e = r;
+  return typeof e == "string" && (e = t.encode(e)), Uint8Array.prototype.toBase64 ? e.toBase64({ alphabet: "base64url", omitPadding: !0 }) : c(e).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
 }
 export {
-  R as handleSendCalls
+  i as decode,
+  p as encode
 };

package/dist/web/index.web148.js

@@ -1,10 +1,12 @@
-import { EIP1193ProviderError as r, STANDARD_ERROR_CODES as t } from "./index.web25.js";
-async function a(n, o, s) {
-  throw new r(
-    t.provider.unsupportedMethod,
-    "eth_sendTransaction is not supported with smart accounts. Use wallet_sendCalls instead."
-  );
-}
+import n from "./index.web170.js";
+import s from "./index.web171.js";
+import a from "./index.web172.js";
+const y = async (t, o, e) => {
+  const r = await a(t, o, "sign");
+  s(t, r);
+  const i = await crypto.subtle.sign(n(t, r.algorithm), r, e);
+  return new Uint8Array(i);
+};
 export {
-  a as handleSendTransaction
+  y as default
 };

package/dist/web/index.web149.js

@@ -1,23 +1,22 @@
-import { hashTypedData as s } from "viem";
-import { signAndWrapTypedDataForSmartAccount as c } from "./index.web46.js";
-import { validateUserOwnsSmartAccount as i, EIP1193ProviderError as d, STANDARD_ERROR_CODES as m } from "./index.web25.js";
-async function A(a, e) {
-  const [t, n] = a, o = await i(t);
-  try {
-    const { signature: r } = await c({
-      smartAccount: t,
-      ownerAddress: o.evmAccounts[0],
-      hash: s(JSON.parse(n)),
-      chainId: e.getState().chainId
-    });
-    return r;
-  } catch (r) {
-    throw new d(
-      m.provider.userRejectedRequest,
-      r instanceof Error ? r.message : "Signing failed"
-    );
+const a = (...o) => {
+  const t = o.filter(Boolean);
+  if (t.length === 0 || t.length === 1)
+    return !0;
+  let e;
+  for (const s of t) {
+    const r = Object.keys(s);
+    if (!e || e.size === 0) {
+      e = new Set(r);
+      continue;
+    }
+    for (const n of r) {
+      if (e.has(n))
+        return !1;
+      e.add(n);
+    }
   }
-}
+  return !0;
+};
 export {
-  A as handleSignTypedData
+  a as default
 };

package/dist/web/index.web15.js

@@ -1,19 +1,19 @@
-import { initiateAuthentication as e } from "@coinbase/cdp-api-client";
-import { Analytics as o } from "./index.web28.js";
-import "./index.web29.js";
-import { getPlatformOAuth as n } from "./index.web2.js";
-import { getCoreAuthManager as r, getConfig as a } from "./index.web39.js";
-async function g(t) {
-  if (o.sendActionCallEvent({ name: "link_oauth" }), !await r().isSignedIn())
-    throw new Error("User must be signed in to link an OAuth account");
-  const i = await e(a().projectId, {
-    type: t,
-    redirectUrl: n().getRedirectUrl()
+import { initiateAuthentication as o } from "@coinbase/cdp-api-client";
+import { Analytics as e } from "./index.web2.js";
+import "./index.web3.js";
+import { getPlatformOAuth as i } from "./index.web4.js";
+import { getCoreAuthManager as n, getConfig as r } from "./index.web44.js";
+async function u() {
+  if (e.sendActionCallEvent({ name: "link_google" }), !await n().isSignedIn())
+    throw new Error("User must be signed in to link a Google account");
+  const t = await o(r().projectId, {
+    type: "google",
+    redirectUrl: i().getRedirectUrl()
   });
-  if (!("authUrl" in i))
-    throw new Error(`Failed to initiate ${t} authentication`);
-  n().initiateOAuthFlow(i.authUrl);
+  if (!("authUrl" in t))
+    throw new Error("Failed to initiate Google authentication");
+  i().initiateOAuthFlow(t.authUrl);
 }
 export {
-  g as linkOAuth
+  u as linkGoogle
 };

package/dist/web/index.web150.js

@@ -1,10 +1,96 @@
-import { __module as e } from "./index.web151.js";
-import { __require as o } from "./index.web152.js";
-import { __require as t } from "./index.web153.js";
-var r;
-function s() {
-  return r ? e.exports : (r = 1, process.env.NODE_ENV === "production" ? e.exports = o() : e.exports = t(), e.exports);
-}
+import { withAlg as n } from "./index.web173.js";
+import c from "./index.web174.js";
+import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.web175.js";
+const s = (r) => r?.[Symbol.toStringTag], o = (r, e, t) => {
+  if (e.use !== void 0) {
+    let i;
+    switch (t) {
+      case "sign":
+      case "verify":
+        i = "sig";
+        break;
+      case "encrypt":
+      case "decrypt":
+        i = "enc";
+        break;
+    }
+    if (e.use !== i)
+      throw new TypeError(`Invalid key for this operation, its "use" must be "${i}" when present`);
+  }
+  if (e.alg !== void 0 && e.alg !== r)
+    throw new TypeError(`Invalid key for this operation, its "alg" must be "${r}" when present`);
+  if (Array.isArray(e.key_ops)) {
+    let i;
+    switch (!0) {
+      case t === "sign":
+      case r === "dir":
+      case r.includes("CBC-HS"):
+        i = t;
+        break;
+      case r.startsWith("PBES2"):
+        i = "deriveBits";
+        break;
+      case /^A\d{3}(?:GCM)?(?:KW)?$/.test(r):
+        !r.includes("GCM") && r.endsWith("KW") ? i = "unwrapKey" : i = t;
+        break;
+      case t === "encrypt":
+        i = "wrapKey";
+        break;
+      case t === "decrypt":
+        i = r.startsWith("RSA") ? "unwrapKey" : "deriveBits";
+        break;
+    }
+    if (i && e.key_ops?.includes?.(i) === !1)
+      throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${i}" when present`);
+  }
+  return !0;
+}, h = (r, e, t) => {
+  if (!(e instanceof Uint8Array)) {
+    if (p(e)) {
+      if (a(e) && o(r, e, t))
+        return;
+      throw new TypeError('JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present');
+    }
+    if (!c(e))
+      throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array"));
+    if (e.type !== "secret")
+      throw new TypeError(`${s(e)} instances for symmetric algorithms must be of type "secret"`);
+  }
+}, m = (r, e, t) => {
+  if (p(e))
+    switch (t) {
+      case "decrypt":
+      case "sign":
+        if (f(e) && o(r, e, t))
+          return;
+        throw new TypeError("JSON Web Key for this operation be a private JWK");
+      case "encrypt":
+      case "verify":
+        if (y(e) && o(r, e, t))
+          return;
+        throw new TypeError("JSON Web Key for this operation be a public JWK");
+    }
+  if (!c(e))
+    throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key"));
+  if (e.type === "secret")
+    throw new TypeError(`${s(e)} instances for asymmetric algorithms must not be of type "secret"`);
+  if (e.type === "public")
+    switch (t) {
+      case "sign":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm signing must be of type "private"`);
+      case "decrypt":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm decryption must be of type "private"`);
+    }
+  if (e.type === "private")
+    switch (t) {
+      case "verify":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm verifying must be of type "public"`);
+      case "encrypt":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm encryption must be of type "public"`);
+    }
+}, d = (r, e, t) => {
+  r.startsWith("HS") || r === "dir" || r.startsWith("PBES2") || /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(r) || /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(r) ? h(r, e, t) : m(r, e, t);
+};
 export {
-  s as __require
+  d as default
 };

package/dist/web/index.web151.js

@@ -1,4 +1,23 @@
-var e = { exports: {} };
+import { JOSENotSupported as f } from "./index.web64.js";
+const w = (n, r, a, e, s) => {
+  if (s.crit !== void 0 && e?.crit === void 0)
+    throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');
+  if (!e || e.crit === void 0)
+    return /* @__PURE__ */ new Set();
+  if (!Array.isArray(e.crit) || e.crit.length === 0 || e.crit.some((i) => typeof i != "string" || i.length === 0))
+    throw new n('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
+  let t;
+  a !== void 0 ? t = new Map([...Object.entries(a), ...r.entries()]) : t = r;
+  for (const i of e.crit) {
+    if (!t.has(i))
+      throw new f(`Extension Header Parameter "${i}" is not recognized`);
+    if (s[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" is missing`);
+    if (t.get(i) && e[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" MUST be integrity protected`);
+  }
+  return new Set(e.crit);
+};
 export {
-  e as __module
+  w as default
 };