@coinbase/cdp-core 0.0.24 → 0.0.25

package/README.md

@@ -37,7 +37,7 @@ in CDP Portal, and click Add origin to include your local app
 
 Before calling any methods in the SDK, you must first initialize it:
 
-```ts
+```ts lines
 import { Config, initialize } from "@coinbase/cdp-core";
 
 const config: Config = {
@@ -52,7 +52,7 @@ await initialize(config);
 
 You can configure the SDK to automatically create Smart Accounts for new users by setting `createAccountOnLogin` to `"evm-smart"`:
 
-```ts
+```ts lines
 const config: Config = {
   projectId: "your-project-id",
   createAccountOnLogin: "evm-smart", // Creates Smart Accounts instead of EOAs
@@ -71,7 +71,7 @@ When `createAccountOnLogin` is set to `"evm-smart"`, the SDK will:
 You're now ready to start calling the APIs provided by the package!
 The following code signs in an end user:
 
-```ts
+```ts lines
 import { signInWithEmail, verifyEmailOTP } from "@coinbase/cdp-core";
 
 // Send an email to user@example.com with a One Time Password (OTP).
@@ -92,7 +92,7 @@ const user = verifyResult.user;
 ### View User Information
 Once the end user has signed in, you can display their information in your application:
 
-```typescript
+```typescript lines
 import { getCurrentUser, isSignedIn } from "@coinbase/cdp-core";
 
 // Check if user is signed in
@@ -122,7 +122,7 @@ We support signing and sending a Blockchain transaction in a single call on the
 - Optimism
 - Polygon
 
-```typescript
+```typescript lines
 import { sendEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
 
 const user = await getCurrentUser();
@@ -148,7 +148,7 @@ console.log("Transaction Hash:", result.transactionHash);
 For networks other than those supported by the CDP APIs, your end user must sign the transaction, and then
 you must broadcast the transaction yourself. This example uses the public client from `viem` to broadcast the transaction. 
 
-```typescript
+```typescript lines
 import { signEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
 import { http, createPublicClient } from "viem";
 import { tron } from "viem/chains";
@@ -190,7 +190,7 @@ Smart Accounts provide advanced account abstraction features, including user ope
 
 Send user operations from a Smart Account:
 
-```typescript
+```typescript lines
 import { sendUserOperation, getCurrentUser } from "@coinbase/cdp-core";
 
 const user = await getCurrentUser();
@@ -217,7 +217,7 @@ console.log("User Operation Hash:", result.userOperationHash);
 
 After sending a user operation, you can get its status and retrieve the result:
 
-```typescript
+```typescript lines
 import { getUserOperation } from "@coinbase/cdp-core";
 
 // Get the status of a user operation
@@ -241,7 +241,7 @@ if (userOperationResult.status === "complete") {
 
 End users can sign EVM messages, hashes, and typed data to generate signatures for various onchain applications.
 
-```typescript
+```typescript lines
 import { signEvmMessage, signEvmTypedData, getCurrentUser } from "@coinbase/cdp-core";
 
 const user = await getCurrentUser();
@@ -281,7 +281,7 @@ const typedDataResult = await signEvmTypedData({
 
 End users can export their private keys from their embedded wallet, allowing them to import it into an EVM-compatible wallet of their choice.
 
-```typescript
+```typescript lines
 import { exportEvmAccount, getCurrentUser } from "@coinbase/cdp-core";
 
 const user = await getCurrentUser();
@@ -302,7 +302,7 @@ The core package includes an EIP-1193 compatible provider. This provider can be
 The provider is created by calling `createCDPEmbeddedWallet`, which exposes a `.provider` attribute. `createCDPEmbeddedWallet` must be called with the desired chains to support as well as the transports for these chains. 
 
 The provider will initially connect to the first chain in the `chains` array. The transports are typically HTTP RPC endpoints, which are used internally for broadcasting non-Base transactions. For more information on transports, see [Wagmi's `createConfig` setup](https://wagmi.sh/react/api/createConfig).
-```typescript
+```typescript lines
 import { base, mainnet } from "viem/chains";
 import { http } from "viem"
 
@@ -351,7 +351,7 @@ provider.on("disconnect", () => {
 
 The core package includes a `toViemAccount` utility function that enables wrapping an embedded wallet into a Viem account compatible interface. This allows the account to act as a drop-in replacement for any library or framework that accepts Viem accounts.
 
-```typescript
+```typescript lines
 import { toViemAccount, getCurrentUser } from "@coinbase/cdp-core";
 import { createWalletClient } from "viem";
 import { mainnet } from "viem/chains";

package/dist/esm/index.js

@@ -1,19 +1,21 @@
-import { exportEvmAccount as i, getAccessToken as s, getCurrentUser as m, getUserOperation as a, initialize as E, isSignedIn as p, onAuthStateChange as g, sendEvmTransaction as c, sendUserOperation as d, signEvmHash as v, signEvmMessage as T, signEvmTransaction as A, signEvmTypedData as f, signInWithEmail as O, signInWithSms as S, signOut as h, verifyEmailOTP as u, verifySmsOTP as x } from "./index2.js";
-import { APIError as P, ErrorType as l, HttpErrorType as D, SendEvmTransactionWithEndUserAccountBodyNetwork as I } from "@coinbase/cdp-api-client";
+import { exportEvmAccount as i, getAccessToken as s, getCurrentUser as m, getUserOperation as a, initialize as E, isSignedIn as p, onAuthStateChange as g, sendEvmTransaction as c, sendUserOperation as d, signEvmHash as v, signEvmMessage as T, signEvmTransaction as f, signEvmTypedData as u, signInWithEmail as A, signInWithSms as l, signOut as x, verifyEmailOTP as O, verifySmsOTP as S } from "./index2.js";
+import { APIError as y, ErrorType as P, HttpErrorType as D, SendEvmTransactionWithEndUserAccountBodyNetwork as I } from "@coinbase/cdp-api-client";
 import "viem";
-import { createCDPEmbeddedWallet as R } from "./index3.js";
+import { createCDPEmbeddedWallet as C } from "./index3.js";
 import { EIP1193ProviderError as W, STANDARD_ERROR_CODES as k } from "./index4.js";
 import "ox";
 import "zustand";
-import { toViemAccount as N } from "./index5.js";
+import { toViemAccount as M } from "./index5.js";
+import { ModuleResolutionError as _ } from "./index6.js";
 export {
-  P as APIError,
+  y as APIError,
   W as EIP1193ProviderError,
-  l as ErrorType,
+  P as ErrorType,
   D as HttpErrorType,
+  _ as ModuleResolutionError,
   k as STANDARD_ERROR_CODES,
   I as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  R as createCDPEmbeddedWallet,
+  C as createCDPEmbeddedWallet,
   i as exportEvmAccount,
   s as getAccessToken,
   m as getCurrentUser,
@@ -25,12 +27,12 @@ export {
   d as sendUserOperation,
   v as signEvmHash,
   T as signEvmMessage,
-  A as signEvmTransaction,
-  f as signEvmTypedData,
-  O as signInWithEmail,
-  S as signInWithSms,
-  h as signOut,
-  N as toViemAccount,
-  u as verifyEmailOTP,
-  x as verifySmsOTP
+  f as signEvmTransaction,
+  u as signEvmTypedData,
+  A as signInWithEmail,
+  l as signInWithSms,
+  x as signOut,
+  M as toViemAccount,
+  O as verifyEmailOTP,
+  S as verifySmsOTP
 };

package/dist/esm/index10.js

@@ -1,17 +1,23 @@
-async function a(e, n) {
-  try {
-    const r = new Uint8Array(Array.from(atob(n), (t) => t.charCodeAt(0))), o = await window.crypto.subtle.decrypt(
-      {
-        name: "RSA-OAEP"
-      },
-      e,
-      r
-    );
-    return Array.from(new Uint8Array(o)).map((t) => t.toString(16).padStart(2, "0")).join("");
-  } catch (r) {
-    throw new Error(`Decryption failed: ${String(r)}`);
-  }
+async function a() {
+  const e = await window.crypto.subtle.generateKey(
+    {
+      name: "RSA-OAEP",
+      modulusLength: 4096,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      // 65537
+      hash: { name: "SHA-256" }
+    },
+    !0,
+    // Allow key export for compatibility with Node version
+    ["encrypt", "decrypt"]
+  ), r = await window.crypto.subtle.exportKey("spki", e.publicKey), t = btoa(
+    Array.from(new Uint8Array(r)).map((n) => String.fromCharCode(n)).join("")
+  );
+  return {
+    privateKey: e.privateKey,
+    publicKeyBase64: t
+  };
 }
 export {
-  a as decryptWithPrivateKey
+  a as createExportKeyPair
 };

package/dist/esm/index100.js

@@ -1,13 +1,10 @@
-import { checkSigCryptoKey as i } from "./index105.js";
-import o from "./index101.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]);
+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`);
   }
-  return i(r, t, e), r;
 };
 export {
-  s as default
+  o as default
 };

package/dist/esm/index101.js

@@ -1,15 +1,13 @@
-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 { checkSigCryptoKey as i } from "./index106.js";
+import o from "./index102.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 {
-  r as default,
-  t as withAlg
+  s as default
 };

package/dist/esm/index102.js

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

package/dist/esm/index103.js

@@ -1,19 +1,12 @@
-import n from "./index84.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";
+  return t?.[Symbol.toStringTag] === "CryptoKey";
 }
-function c(t) {
-  return t.kty === "oct" && typeof t.k == "string";
+function r(t) {
+  return t?.[Symbol.toStringTag] === "KeyObject";
 }
+const n = (t) => e(t) || r(t);
 export {
-  r as isJWK,
-  o as isPrivateJWK,
-  e as isPublicJWK,
-  c as isSecretJWK
+  n as default,
+  e as isCryptoKey,
+  r as isKeyObject
 };

package/dist/esm/index104.js

@@ -1,83 +1,19 @@
-import { JOSENotSupported as s } from "./index71.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 };
+import n from "./index87.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";
 }
-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
+  r as isJWK,
+  o as isPrivateJWK,
+  e as isPublicJWK,
+  c as isSecretJWK
 };

package/dist/esm/index105.js

@@ -1,81 +1,83 @@
-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");
+import { JOSENotSupported as s } from "./index72.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 "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");
+    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 "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");
+    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 TypeError("CryptoKey does not support this operation");
+      throw new s('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
   }
-  i(t, n);
+  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 {
-  u as checkSigCryptoKey
+  i as default
 };

package/dist/esm/index106.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
+};