@coinbase/cdp-core 0.0.110 → 0.0.112

package/dist/native/index.native218.js

@@ -1,17 +1,96 @@
-var f, e;
-function t() {
-  if (e) return f;
-  e = 1, f = function(r) {
-    return r != null && (u(r) || n(r) || !!r._isBuffer);
-  };
-  function u(r) {
-    return !!r.constructor && typeof r.constructor.isBuffer == "function" && r.constructor.isBuffer(r);
+import { withAlg as n } from "./index.native245.js";
+import c from "./index.native246.js";
+import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.native247.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`);
   }
-  function n(r) {
-    return typeof r.readFloatLE == "function" && typeof r.slice == "function" && u(r.slice(0, 0));
+  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 f;
-}
+  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 {
-  t as __require
+  d as default
 };

package/dist/native/index.native219.js

@@ -1,10 +1,23 @@
-import { __module as e } from "./index.native220.js";
-import { __require as o } from "./index.native221.js";
-import { __require as t } from "./index.native222.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 { JOSENotSupported as f } from "./index.native131.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 {
-  s as __require
+  w as default
 };

package/dist/native/index.native22.js

@@ -1,56 +1,61 @@
-import { authenticateUserWithCustomAuth as h } from "@coinbase/cdp-api-client";
-import { Analytics as w } from "./index.native2.js";
+import { authenticateUserWithCustomAuth as f } from "@coinbase/cdp-api-client";
+import { Analytics as h } from "./index.native2.js";
 import "./index.native3.js";
-import { CUSTOM_AUTH_REFRESH_BUFFER_MS as f } from "./index.native124.js";
+import { CUSTOM_AUTH_REFRESH_BUFFER_MS as w } from "./index.native124.js";
 import { toAuthState as g } from "./index.native103.js";
-import { mockUser as c } from "./index.native108.js";
-import { createEvmAccountIfNeeded as l } from "./index.native125.js";
-import { createSolanaAccountIfNeeded as A } from "./index.native126.js";
-import { getConfig as u, getCoreAuthManager as a } from "./index.native76.js";
-import { CustomAuthError as i } from "./index.native88.js";
-const M = async (m) => {
-  w.sendActionCallEvent({ name: "authenticate_with_jwt" });
+import { mockUser as s } from "./index.native108.js";
+import { createBtcAccountIfNeeded as l } from "./index.native125.js";
+import { createEvmAccountIfNeeded as A } from "./index.native126.js";
+import { createSolanaAccountIfNeeded as d } from "./index.native127.js";
+import { getConfig as u, getCoreAuthManager as n } from "./index.native76.js";
+import { CustomAuthError as a } from "./index.native88.js";
+const I = async (m) => {
+  h.sendActionCallEvent({ name: "authenticate_with_jwt" });
   const t = u();
   if (!t.customAuth?.getJwt)
-    throw new i(
+    throw new a(
       "customAuth.getJwt callback not configured. Please provide customAuth with getJwt in initialize() config."
     );
   let e;
   try {
     e = await t.customAuth.getJwt();
-  } catch (s) {
-    throw new i(
-      s instanceof Error ? s.message : "Failed to get custom auth JWT"
+  } catch (i) {
+    throw new a(
+      i instanceof Error ? i.message : "Failed to get custom auth JWT"
     );
   }
   if (!e)
-    throw new i("customAuth.getJwt returned null or undefined");
+    throw new a("customAuth.getJwt returned null or undefined");
   if (t.useMock)
-    return await a().setAuthState({
+    return await n().setAuthState({
       accessToken: e,
       expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
-      user: c
+      user: s
     }), {
       message: "Mock JWT authentication successful",
-      user: c,
+      user: s,
       isNewUser: !1
     };
-  const n = await h(
+  const c = await f(
     u().projectId,
     m?.idempotencyKey
-  ), r = new Date(Date.now() + f).toISOString();
-  let o = g(e, r, n.endUser);
-  return await a().setAuthState(o), t.ethereum?.createOnLogin && (o = await l(
+  ), r = new Date(Date.now() + w).toISOString();
+  let o = g(e, r, c.endUser);
+  if (await n().setAuthState(o), t.ethereum?.createOnLogin && (o = await A(
     o,
     e,
     r,
     t.ethereum.createOnLogin
-  )), t.solana?.createOnLogin && (o = await A(o, e, r)), {
+  )), t.solana?.createOnLogin && (o = await d(o, e, r)), t.bitcoin?.createOnLogin) {
+    const i = [t.bitcoin.createOnLogin].flat();
+    o = await l(o, e, r, i);
+  }
+  return {
     message: "Authentication successful",
-    user: a().getUser(),
-    isNewUser: n.isNewEndUser
+    user: n().getUser(),
+    isNewUser: c.isNewEndUser
   };
 };
 export {
-  M as authenticateWithJWT
+  I as authenticateWithJWT
 };

package/dist/native/index.native220.js

@@ -1,4 +1,120 @@
-var e = { exports: {} };
+import { isJWK as p } from "./index.native247.js";
+import { decode as m } from "./index.native215.js";
+import y from "./index.native248.js";
+import { isCryptoKey as S, isKeyObject as K } from "./index.native246.js";
+let c;
+const f = async (e, r, s, i = !1) => {
+  c ||= /* @__PURE__ */ new WeakMap();
+  let n = c.get(e);
+  if (n?.[s])
+    return n[s];
+  const t = await y({ ...r, alg: s });
+  return i && Object.freeze(e), n ? n[s] = t : c.set(e, { [s]: t }), t;
+}, E = (e, r) => {
+  c ||= /* @__PURE__ */ new WeakMap();
+  let s = c.get(e);
+  if (s?.[r])
+    return s[r];
+  const i = e.type === "public", n = !!i;
+  let t;
+  if (e.asymmetricKeyType === "x25519") {
+    switch (r) {
+      case "ECDH-ES":
+      case "ECDH-ES+A128KW":
+      case "ECDH-ES+A192KW":
+      case "ECDH-ES+A256KW":
+        break;
+      default:
+        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    }
+    t = e.toCryptoKey(e.asymmetricKeyType, n, i ? [] : ["deriveBits"]);
+  }
+  if (e.asymmetricKeyType === "ed25519") {
+    if (r !== "EdDSA" && r !== "Ed25519")
+      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    t = e.toCryptoKey(e.asymmetricKeyType, n, [
+      i ? "verify" : "sign"
+    ]);
+  }
+  if (e.asymmetricKeyType === "rsa") {
+    let a;
+    switch (r) {
+      case "RSA-OAEP":
+        a = "SHA-1";
+        break;
+      case "RS256":
+      case "PS256":
+      case "RSA-OAEP-256":
+        a = "SHA-256";
+        break;
+      case "RS384":
+      case "PS384":
+      case "RSA-OAEP-384":
+        a = "SHA-384";
+        break;
+      case "RS512":
+      case "PS512":
+      case "RSA-OAEP-512":
+        a = "SHA-512";
+        break;
+      default:
+        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    }
+    if (r.startsWith("RSA-OAEP"))
+      return e.toCryptoKey({
+        name: "RSA-OAEP",
+        hash: a
+      }, n, i ? ["encrypt"] : ["decrypt"]);
+    t = e.toCryptoKey({
+      name: r.startsWith("PS") ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
+      hash: a
+    }, n, [i ? "verify" : "sign"]);
+  }
+  if (e.asymmetricKeyType === "ec") {
+    const o = (/* @__PURE__ */ new Map([
+      ["prime256v1", "P-256"],
+      ["secp384r1", "P-384"],
+      ["secp521r1", "P-521"]
+    ])).get(e.asymmetricKeyDetails?.namedCurve);
+    if (!o)
+      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    r === "ES256" && o === "P-256" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r === "ES384" && o === "P-384" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r === "ES512" && o === "P-521" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r.startsWith("ECDH-ES") && (t = e.toCryptoKey({
+      name: "ECDH",
+      namedCurve: o
+    }, n, i ? [] : ["deriveBits"]));
+  }
+  if (!t)
+    throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+  return s ? s[r] = t : c.set(e, { [r]: t }), t;
+}, d = async (e, r) => {
+  if (e instanceof Uint8Array || S(e))
+    return e;
+  if (K(e)) {
+    if (e.type === "secret")
+      return e.export();
+    if ("toCryptoKey" in e && typeof e.toCryptoKey == "function")
+      try {
+        return E(e, r);
+      } catch (i) {
+        if (i instanceof TypeError)
+          throw i;
+      }
+    let s = e.export({ format: "jwk" });
+    return f(e, s, r);
+  }
+  if (p(e))
+    return e.k ? m(e.k) : f(e, e, r, !0);
+  throw new Error("unreachable");
+};
 export {
-  e as __module
+  d as default
 };