@coinbase/cdp-core 0.0.36 → 0.0.37

package/dist/native-types/platform/types.d.ts

@@ -4,7 +4,7 @@ export interface PlatformCrypto {
     createExportKeyPair(): Promise<KeyPair>;
     hash(data: Uint8Array): Promise<string>;
     generateRandomId(): string;
-    decryptWithPrivateKey(privateKey: CryptoKey, encryptedData: string): Promise<string>;
+    decryptWithPrivateKey(privateKey: CryptoKey, encryptedData: string): Promise<ArrayBuffer>;
 }
 export interface PlatformStorage {
     getItem(key: string): Promise<string | null>;

package/dist/native-types/types.d.ts

@@ -102,6 +102,13 @@ export type SignSolanaTransactionOptions = {
 export type SignSolanaTransactionResult = {
     signedTransaction: string;
 };
+export type SignSolanaMessageOptions = {
+    solanaAccount: SolanaAddress;
+    message: string;
+};
+export type SignSolanaMessageResult = {
+    signature: string;
+};
 export type SendEvmTransactionOptions = {
     evmAccount: EvmAddress;
     network: SendEvmTransactionWithEndUserAccountBodyNetwork;
@@ -178,3 +185,9 @@ export type ExportEvmAccountOptions = {
 export type ExportEvmAccountResult = {
     privateKey: string;
 };
+export type ExportSolanaAccountOptions = {
+    solanaAccount: SolanaAddress;
+};
+export type ExportSolanaAccountResult = {
+    privateKey: string;
+};

package/dist/types/core.d.ts

@@ -1,4 +1,4 @@
-import { Config, User, SignInWithEmailOptions, SignInWithEmailResult, SignInWithSmsOptions, SignInWithSmsResult, VerifySmsOTPOptions, VerifySmsOTPResult, SignEvmHashOptions, SignEvmHashResult, VerifyEmailOTPOptions, VerifyEmailOTPResult, OnAuthStateChangeFn, SendEvmTransactionResult, SignEvmTransactionOptions, SignEvmTransactionResult, SignSolanaTransactionOptions, SignSolanaTransactionResult, SignEvmTypedDataOptions, SignEvmTypedDataResult, SignEvmMessageOptions, ExportEvmAccountResult, SendEvmTransactionOptions, SendSolanaTransactionOptions, SendSolanaTransactionResult, ExportEvmAccountOptions, SendUserOperationOptions, SendUserOperationResult, GetUserOperationOptions, GetUserOperationResult } from './types.js';
+import { Config, User, SignInWithEmailOptions, SignInWithEmailResult, SignInWithSmsOptions, SignInWithSmsResult, VerifySmsOTPOptions, VerifySmsOTPResult, SignEvmHashOptions, SignEvmHashResult, VerifyEmailOTPOptions, VerifyEmailOTPResult, OnAuthStateChangeFn, SendEvmTransactionResult, SignEvmTransactionOptions, SignEvmTransactionResult, SignSolanaTransactionOptions, SignSolanaTransactionResult, SignEvmTypedDataOptions, SignEvmTypedDataResult, SignEvmMessageOptions, SignSolanaMessageOptions, SignSolanaMessageResult, ExportEvmAccountResult, SendEvmTransactionOptions, SendSolanaTransactionOptions, SendSolanaTransactionResult, ExportEvmAccountOptions, ExportSolanaAccountOptions, ExportSolanaAccountResult, SendUserOperationOptions, SendUserOperationResult, GetUserOperationOptions, GetUserOperationResult } from './types.js';
 export declare const initialize: (cfg: Config) => Promise<void>;
 export declare const signInWithEmail: (options: SignInWithEmailOptions) => Promise<SignInWithEmailResult>;
 export declare const signInWithSms: (options: SignInWithSmsOptions) => Promise<SignInWithSmsResult>;
@@ -15,7 +15,9 @@ export declare const signSolanaTransaction: (options: SignSolanaTransactionOptio
 export declare const sendEvmTransaction: (options: SendEvmTransactionOptions) => Promise<SendEvmTransactionResult>;
 export declare const sendSolanaTransaction: (options: SendSolanaTransactionOptions) => Promise<SendSolanaTransactionResult>;
 export declare const signEvmMessage: (options: SignEvmMessageOptions) => Promise<SignEvmHashResult>;
+export declare const signSolanaMessage: (options: SignSolanaMessageOptions) => Promise<SignSolanaMessageResult>;
 export declare const signEvmTypedData: (options: SignEvmTypedDataOptions) => Promise<SignEvmTypedDataResult>;
 export declare const sendUserOperation: (options: SendUserOperationOptions) => Promise<SendUserOperationResult>;
 export declare const getUserOperation: (options: GetUserOperationOptions) => Promise<GetUserOperationResult>;
 export declare const exportEvmAccount: (options: ExportEvmAccountOptions) => Promise<ExportEvmAccountResult>;
+export declare const exportSolanaAccount: (options: ExportSolanaAccountOptions) => Promise<ExportSolanaAccountResult>;

package/dist/types/platform/types.d.ts

@@ -4,7 +4,7 @@ export interface PlatformCrypto {
     createExportKeyPair(): Promise<KeyPair>;
     hash(data: Uint8Array): Promise<string>;
     generateRandomId(): string;
-    decryptWithPrivateKey(privateKey: CryptoKey, encryptedData: string): Promise<string>;
+    decryptWithPrivateKey(privateKey: CryptoKey, encryptedData: string): Promise<ArrayBuffer>;
 }
 export interface PlatformStorage {
     getItem(key: string): Promise<string | null>;

package/dist/types/types.d.ts

@@ -102,6 +102,13 @@ export type SignSolanaTransactionOptions = {
 export type SignSolanaTransactionResult = {
     signedTransaction: string;
 };
+export type SignSolanaMessageOptions = {
+    solanaAccount: SolanaAddress;
+    message: string;
+};
+export type SignSolanaMessageResult = {
+    signature: string;
+};
 export type SendEvmTransactionOptions = {
     evmAccount: EvmAddress;
     network: SendEvmTransactionWithEndUserAccountBodyNetwork;
@@ -178,3 +185,9 @@ export type ExportEvmAccountOptions = {
 export type ExportEvmAccountResult = {
     privateKey: string;
 };
+export type ExportSolanaAccountOptions = {
+    solanaAccount: SolanaAddress;
+};
+export type ExportSolanaAccountResult = {
+    privateKey: string;
+};

package/dist/web/index.web.js

@@ -1,50 +1,52 @@
 import { setPlatformServices as r } from "./index.web2.js";
 import { webCrypto as o } from "./index.web3.js";
 import { webStorage as e } from "./index.web4.js";
-import { exportEvmAccount as c, getAccessToken as g, getCurrentUser as d, getUserOperation as f, initialize as S, isSignedIn as T, onAuthStateChange as l, sendEvmTransaction as v, sendSolanaTransaction as u, sendUserOperation as A, signEvmHash as y, signEvmMessage as h, signEvmTransaction as x, signEvmTypedData as O, signInWithEmail as P, signInWithSms as C, signOut as D, signSolanaTransaction as I, verifyEmailOTP as R, verifySmsOTP as U } from "./index.web5.js";
-import { AuthManager as w } from "./index.web6.js";
-import { APIError as k, ErrorType as M, HttpErrorType as N, SendEvmTransactionWithEndUserAccountBodyNetwork as B, SendSolanaTransactionWithEndUserAccountBodyNetwork as H } from "@coinbase/cdp-api-client";
+import { exportEvmAccount as E, exportSolanaAccount as g, getAccessToken as d, getCurrentUser as S, getUserOperation as f, initialize as l, isSignedIn as T, onAuthStateChange as u, sendEvmTransaction as v, sendSolanaTransaction as A, sendUserOperation as x, signEvmHash as y, signEvmMessage as h, signEvmTransaction as O, signEvmTypedData as P, signInWithEmail as C, signInWithSms as D, signOut as I, signSolanaMessage as R, signSolanaTransaction as U, verifyEmailOTP as W, verifySmsOTP as w } from "./index.web5.js";
+import { AuthManager as b } from "./index.web6.js";
+import { APIError as N, ErrorType as B, HttpErrorType as H, SendEvmTransactionWithEndUserAccountBodyNetwork as _, SendSolanaTransactionWithEndUserAccountBodyNetwork as z } from "@coinbase/cdp-api-client";
 import "viem";
-import { createCDPEmbeddedWallet as z } from "./index.web7.js";
-import { EIP1193ProviderError as j, STANDARD_ERROR_CODES as q } from "./index.web8.js";
+import { createCDPEmbeddedWallet as j } from "./index.web7.js";
+import { EIP1193ProviderError as F, STANDARD_ERROR_CODES as G } from "./index.web8.js";
 import "ox";
 import "zustand";
-import { toViemAccount as G } from "./index.web9.js";
-import { ModuleResolutionError as K } from "./index.web10.js";
+import { toViemAccount as K } from "./index.web9.js";
+import { ModuleResolutionError as Q } from "./index.web10.js";
 r({
   crypto: o,
   storage: e
 });
 export {
-  k as APIError,
-  w as AuthManager,
-  j as EIP1193ProviderError,
-  M as ErrorType,
-  N as HttpErrorType,
-  K as ModuleResolutionError,
-  q as STANDARD_ERROR_CODES,
-  B as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  H as SendSolanaTransactionWithEndUserAccountBodyNetwork,
-  z as createCDPEmbeddedWallet,
-  c as exportEvmAccount,
-  g as getAccessToken,
-  d as getCurrentUser,
+  N as APIError,
+  b as AuthManager,
+  F as EIP1193ProviderError,
+  B as ErrorType,
+  H as HttpErrorType,
+  Q as ModuleResolutionError,
+  G as STANDARD_ERROR_CODES,
+  _ as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  z as SendSolanaTransactionWithEndUserAccountBodyNetwork,
+  j as createCDPEmbeddedWallet,
+  E as exportEvmAccount,
+  g as exportSolanaAccount,
+  d as getAccessToken,
+  S as getCurrentUser,
   f as getUserOperation,
-  S as initialize,
+  l as initialize,
   T as isSignedIn,
-  l as onAuthStateChange,
+  u as onAuthStateChange,
   v as sendEvmTransaction,
-  u as sendSolanaTransaction,
-  A as sendUserOperation,
+  A as sendSolanaTransaction,
+  x as sendUserOperation,
   y as signEvmHash,
   h as signEvmMessage,
-  x as signEvmTransaction,
-  O as signEvmTypedData,
-  P as signInWithEmail,
-  C as signInWithSms,
-  D as signOut,
-  I as signSolanaTransaction,
-  G as toViemAccount,
-  R as verifyEmailOTP,
-  U as verifySmsOTP
+  O as signEvmTransaction,
+  P as signEvmTypedData,
+  C as signInWithEmail,
+  D as signInWithSms,
+  I as signOut,
+  R as signSolanaMessage,
+  U as signSolanaTransaction,
+  K as toViemAccount,
+  W as verifyEmailOTP,
+  w as verifySmsOTP
 };

package/dist/web/index.web100.js

@@ -1,15 +1,9 @@
-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);
+import { bytesToHex as i } from "./index.web46.js";
+import { sha256 as m } from "./index.web69.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 {
-  r as default,
-  t as withAlg
+  f as commitmentToVersionedHash
 };

package/dist/web/index.web101.js

@@ -1,12 +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);
+import { contracts as o } from "./index.web111.js";
+import { formatters as r } from "./index.web112.js";
+import { serializers as t } from "./index.web113.js";
+const e = {
+  blockTime: 2e3,
+  contracts: o,
+  formatters: r,
+  serializers: t
+};
 export {
-  n as default,
-  e as isCryptoKey,
-  r as isKeyObject
+  e as chainConfig
 };

package/dist/web/index.web102.js

@@ -1,19 +1,20 @@
-import n from "./index.web79.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";
+  if (Uint8Array.prototype.toBase64)
+    return t.toBase64();
+  const e = 32768, n = [];
+  for (let r = 0; r < t.length; r += e)
+    n.push(String.fromCharCode.apply(null, t.subarray(r, r + e)));
+  return btoa(n.join(""));
 }
-function c(t) {
-  return t.kty === "oct" && typeof t.k == "string";
+function a(t) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(t);
+  const e = atob(t), n = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    n[r] = e.charCodeAt(r);
+  return n;
 }
 export {
-  r as isJWK,
-  o as isPrivateJWK,
-  e as isPublicJWK,
-  c as isSecretJWK
+  a as decodeBase64,
+  o as encodeBase64
 };

package/dist/web/index.web103.js

@@ -1,83 +1,30 @@
-import { JOSENotSupported as s } from "./index.web28.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;
-    }
+import { JOSENotSupported as r } from "./index.web25.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 s('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
+      throw new r(`alg ${e} is not supported either by JOSE or your javascript runtime`);
   }
-  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
+  S as default
 };

package/dist/web/index.web104.js

@@ -1,15 +1,10 @@
-const s = {
-  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
-  l1Block: { address: "0x4200000000000000000000000000000000000015" },
-  l2CrossDomainMessenger: {
-    address: "0x4200000000000000000000000000000000000007"
-  },
-  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
-  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
-  l2ToL1MessagePasser: {
-    address: "0x4200000000000000000000000000000000000016"
+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 {
-  s as contracts
+  o as default
 };

package/dist/web/index.web105.js

@@ -1,38 +1,13 @@
-import { hexToBigInt as n } from "./index.web48.js";
-import { defineBlock as r } from "./index.web45.js";
-import { defineTransaction as s, formatTransaction as m } from "./index.web47.js";
-import { defineTransactionReceipt as l } from "./index.web50.js";
-const p = {
-  block: /* @__PURE__ */ r({
-    format(e) {
-      return {
-        transactions: e.transactions?.map((t) => {
-          if (typeof t == "string")
-            return t;
-          const i = m(t);
-          return i.typeHex === "0x7e" && (i.isSystemTx = t.isSystemTx, i.mint = t.mint ? n(t.mint) : void 0, i.sourceHash = t.sourceHash, i.type = "deposit"), i;
-        }),
-        stateRoot: e.stateRoot
-      };
-    }
-  }),
-  transaction: /* @__PURE__ */ s({
-    format(e) {
-      const o = {};
-      return e.type === "0x7e" && (o.isSystemTx = e.isSystemTx, o.mint = e.mint ? n(e.mint) : void 0, o.sourceHash = e.sourceHash, o.type = "deposit"), o;
-    }
-  }),
-  transactionReceipt: /* @__PURE__ */ l({
-    format(e) {
-      return {
-        l1GasPrice: e.l1GasPrice ? n(e.l1GasPrice) : null,
-        l1GasUsed: e.l1GasUsed ? n(e.l1GasUsed) : null,
-        l1Fee: e.l1Fee ? n(e.l1Fee) : null,
-        l1FeeScalar: e.l1FeeScalar ? Number(e.l1FeeScalar) : null
-      };
-    }
-  })
+import { checkSigCryptoKey as i } from "./index.web114.js";
+import o from "./index.web106.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 {
-  p as formatters
+  s as default
 };

package/dist/web/index.web106.js

@@ -1,44 +1,15 @@
-import { InvalidAddressError as a } from "./index.web63.js";
-import { isAddress as f } from "./index.web37.js";
-import { concatHex as p } from "./index.web38.js";
-import { toHex as i } from "./index.web32.js";
-import { toRlp as x } from "./index.web51.js";
-import { serializeTransaction as l } from "./index.web18.js";
-function T(r, e) {
-  return h(r) ? z(r) : l(r, e);
+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 E = {
-  transaction: T
-};
-function z(r) {
-  w(r);
-  const { sourceHash: e, data: o, from: m, gas: t, isSystemTx: u, mint: s, to: c, value: n } = r, d = [
-    e,
-    m,
-    c ?? "0x",
-    s ? i(s) : "0x",
-    n ? i(n) : "0x",
-    t ? i(t) : "0x",
-    u ? "0x1" : "0x",
-    o ?? "0x"
-  ];
-  return p([
-    "0x7e",
-    x(d)
-  ]);
-}
-function h(r) {
-  return r.type === "deposit" || typeof r.sourceHash < "u";
-}
-function w(r) {
-  const { from: e, to: o } = r;
-  if (e && !f(e))
-    throw new a({ address: e });
-  if (o && !f(o))
-    throw new a({ address: o });
+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 {
-  w as assertTransactionDeposit,
-  T as serializeTransaction,
-  E as serializers
+  r as default,
+  t as withAlg
 };

package/dist/web/index.web107.js

@@ -1,81 +1,12 @@
-function r(t, e = "algorithm.name") {
-  return new TypeError(`CryptoKey does not support this operation, its ${e} must be ${t}`);
+function e(t) {
+  return t?.[Symbol.toStringTag] === "CryptoKey";
 }
-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);
+function r(t) {
+  return t?.[Symbol.toStringTag] === "KeyObject";
 }
+const n = (t) => e(t) || r(t);
 export {
-  u as checkSigCryptoKey
+  n as default,
+  e as isCryptoKey,
+  r as isKeyObject
 };

package/dist/web/index.web108.js

@@ -0,0 +1,19 @@
+import n from "./index.web43.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
+};