@coinbase/cdp-core 0.0.32 → 0.0.34

package/README.md

@@ -48,10 +48,11 @@ const config: Config = {
 await initialize(config);
 ```
 
-#### Smart Account Configuration
+#### Account Configuration
 
-You can configure the SDK to automatically create Smart Accounts for new users by setting `createAccountOnLogin` to `"evm-smart"`:
+You can configure the SDK to create different types of accounts for new users:
 
+**Smart Account Configuration:**
 ```ts lines
 const config: Config = {
   projectId: "your-project-id",
@@ -66,6 +67,20 @@ When `createAccountOnLogin` is set to `"evm-smart"`, the SDK will:
 2. Use that EOA as the owner to create a Smart Account
 3. Both accounts will be available on the user object
 
+**Solana Account Configuration:**
+```ts lines
+const config: Config = {
+  projectId: "your-project-id",
+  createAccountOnLogin: "solana", // Creates Solana accounts instead of EVM accounts
+}
+
+await initialize(config);
+```
+
+When `createAccountOnLogin` is set to `"solana"`, the SDK will:
+1. Create a Solana account for new users
+2. The Solana account will be available on the `solanaAccounts` property
+
 ### Sign In a User
 
 You're now ready to start calling the APIs provided by the package!
@@ -102,17 +117,27 @@ if (signedIn) {
   // Get the user's information
   const user = await getCurrentUser();
   console.log("User ID:", user.userId);
-  console.log("EVM Accounts (EOAs):", user.evmAccounts);
-  console.log("EVM Smart Accounts:", user.evmSmartAccounts);
+
+  // Display different account types based on configuration
+  if (user.evmAccounts?.length > 0) {
+    console.log("EVM Accounts (EOAs):", user.evmAccounts);
+  }
+  if (user.evmSmartAccounts?.length > 0) {
+    console.log("EVM Smart Accounts:", user.evmSmartAccounts);
+  }
+  if (user.solanaAccounts?.length > 0) {
+    console.log("Solana Accounts:", user.solanaAccounts);
+  }
 
   // Find the user's email address (if they logged in with email/otp)
   const email = user.authenticationMethods.email?.email;
-  console.log("Email Address": email)
+  console.log("Email Address:", email);
 }
 ```
 
-### Send a Transaction
-We support signing and sending a Blockchain transaction in a single call on the following networks:
+### Send an EVM Transaction
+
+We support signing and sending an EVM transaction in a single call on the following networks:
 - Base
 - Base Sepolia
 - Ethereum
@@ -145,7 +170,7 @@ const result = await sendEvmTransaction({
 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
+For EVM 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 lines
@@ -186,6 +211,47 @@ const hash = await client.sendRawTransaction({
 
 Smart Accounts provide advanced account abstraction features, including user operations and paymaster support.
 
+### Sign a Solana Transaction
+
+When your application is configured with `createAccountOnLogin: "solana"`, you can sign Solana transactions:
+
+```typescript lines
+import { signSolanaTransaction, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const solanaAccount = user.solanaAccounts[0];
+
+const result = await signSolanaTransaction({
+  solanaAccount,
+  transaction: "base64-encoded-solana-transaction"  // Your Solana transaction here
+});
+
+console.log("Signed Transaction:", result.signedTransaction);
+// The signedTransaction can now be broadcast to the Solana network
+```
+
+### Send a Solana Transaction
+
+You can sign and send a Solana transaction in a single call on the following Solana networks:
+- Solana Mainnet
+- Solana Devnet
+
+```typescript lines
+import { sendSolanaTransaction, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const solanaAccount = user.solanaAccounts[0];
+
+const result = await sendSolanaTransaction({
+  solanaAccount,
+  network: "solana-devnet", // or "solana" for mainnet
+  transaction: "base64-encoded-solana-transaction"  // Your Solana transaction here
+});
+
+console.log("Transaction Signature:", result.transactionSignature);
+// The transaction has been broadcast to the Solana network
+```
+
 #### Send User Operations
 
 Send user operations from a Smart Account:

package/dist/esm/index.native.js

@@ -1,47 +1,52 @@
 import { nativeCrypto as r } from "./index.native2.js";
-import { nativeStorage as e } from "./index.native3.js";
-import { setPlatformServices as o } from "./index.native4.js";
-import { exportEvmAccount as g, getAccessToken as c, getCurrentUser as f, getUserOperation as v, initialize as d, isSignedIn as T, onAuthStateChange as u, sendEvmTransaction as A, sendUserOperation as S, signEvmHash as l, signEvmMessage as x, signEvmTransaction as y, signEvmTypedData as h, signInWithEmail as O, signInWithSms as P, signOut as C, verifyEmailOTP as D, verifySmsOTP as I } from "./index.native5.js";
-import { AuthManager as U } from "./index.native6.js";
-import { APIError as M, ErrorType as k, HttpErrorType as H, SendEvmTransactionWithEndUserAccountBodyNetwork as N } from "@coinbase/cdp-api-client";
+import { nativeSecureStorage as o } from "./index.native3.js";
+import { nativeStorage as e } from "./index.native4.js";
+import { setPlatformServices as t } from "./index.native5.js";
+import { exportEvmAccount as d, getAccessToken as S, getCurrentUser as f, getUserOperation as v, initialize as T, isSignedIn as u, onAuthStateChange as l, sendEvmTransaction as A, sendSolanaTransaction as y, sendUserOperation as h, signEvmHash as x, signEvmMessage as O, signEvmTransaction as P, signEvmTypedData as C, signInWithEmail as D, signInWithSms as I, signOut as R, signSolanaTransaction as U, verifyEmailOTP as W, verifySmsOTP as k } from "./index.native6.js";
+import { AuthManager as N } from "./index.native7.js";
+import { APIError as B, ErrorType as H, HttpErrorType as _, SendEvmTransactionWithEndUserAccountBodyNetwork as b, SendSolanaTransactionWithEndUserAccountBodyNetwork as z } from "@coinbase/cdp-api-client";
 import "viem";
-import { createCDPEmbeddedWallet as b } from "./index.native7.js";
-import { EIP1193ProviderError as z, STANDARD_ERROR_CODES as B } from "./index.native8.js";
+import { createCDPEmbeddedWallet as j } from "./index.native8.js";
+import { EIP1193ProviderError as F, STANDARD_ERROR_CODES as G } from "./index.native9.js";
 import "ox";
 import "zustand";
-import { toViemAccount as j } from "./index.native9.js";
-import { ModuleResolutionError as F } from "./index.native10.js";
-o({
+import { toViemAccount as K } from "./index.native10.js";
+import { ModuleResolutionError as Q } from "./index.native11.js";
+t({
   crypto: r,
-  storage: e
+  storage: e,
+  secureStorage: o
 });
 export {
-  M as APIError,
-  U as AuthManager,
-  z as EIP1193ProviderError,
-  k as ErrorType,
-  H as HttpErrorType,
-  F as ModuleResolutionError,
-  B as STANDARD_ERROR_CODES,
-  N as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  b as createCDPEmbeddedWallet,
-  g as exportEvmAccount,
-  c as getAccessToken,
+  B as APIError,
+  N as AuthManager,
+  F as EIP1193ProviderError,
+  H as ErrorType,
+  _ as HttpErrorType,
+  Q as ModuleResolutionError,
+  G as STANDARD_ERROR_CODES,
+  b as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  z as SendSolanaTransactionWithEndUserAccountBodyNetwork,
+  j as createCDPEmbeddedWallet,
+  d as exportEvmAccount,
+  S as getAccessToken,
   f as getCurrentUser,
   v as getUserOperation,
-  d as initialize,
-  T as isSignedIn,
-  u as onAuthStateChange,
+  T as initialize,
+  u as isSignedIn,
+  l as onAuthStateChange,
   A as sendEvmTransaction,
-  S as sendUserOperation,
-  l as signEvmHash,
-  x as signEvmMessage,
-  y as signEvmTransaction,
-  h as signEvmTypedData,
-  O as signInWithEmail,
-  P as signInWithSms,
-  C as signOut,
-  j as toViemAccount,
-  D as verifyEmailOTP,
-  I as verifySmsOTP
+  y as sendSolanaTransaction,
+  h as sendUserOperation,
+  x as signEvmHash,
+  O as signEvmMessage,
+  P as signEvmTransaction,
+  C as signEvmTypedData,
+  D as signInWithEmail,
+  I as signInWithSms,
+  R as signOut,
+  U as signSolanaTransaction,
+  K as toViemAccount,
+  W as verifyEmailOTP,
+  k as verifySmsOTP
 };

package/dist/esm/index.native10.js

@@ -1,24 +1,118 @@
-class i extends Error {
-  /**
-   * The name of the missing module.
-   */
-  moduleName;
-  /**
-   * The API or feature that requires the missing module.
-   */
-  requiredFor;
-  /**
-   * Creates a new ModuleResolutionError.
-   *
-   * @param moduleName - The name of the missing module.
-   * @param requiredFor - The API or feature that requires the module.
-   * @param message - Optional custom error message.
-   */
-  constructor(e, s, r) {
-    const o = `${s} is not available in this React Native environment. Please ensure ${e} is installed.`;
-    super(r || o), this.name = "ModuleResolutionError", this.moduleName = e, this.requiredFor = s;
-  }
+import { serializeErc6492Signature as i, encodeFunctionData as c, pad as u, getTypesForEIP712Domain as m } from "viem";
+import { getCurrentUser as g, signEvmHash as A, signEvmTypedData as l, signEvmTransaction as d, signEvmMessage as f } from "./index.native6.js";
+import "@coinbase/cdp-api-client";
+import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as y, COINBASE_SMART_WALLET_FACTORY_ABI as p } from "./index.native22.js";
+import { signAndWrapTypedDataForSmartAccount as v } from "./index.native23.js";
+import { toAccount as w } from "./index.native24.js";
+async function F(n) {
+  const r = await g();
+  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 f({
+        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 d({
+        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],
+          typedData: e
+        });
+        return i({
+          address: y,
+          data: c({
+            abi: p,
+            functionName: "createAccount",
+            args: [[u(r.evmAccounts?.[0])], 0n]
+          }),
+          signature: t.signature
+        });
+      } else {
+        const t = {
+          domain: e.domain,
+          types: {
+            EIP712Domain: m({
+              domain: e.domain
+            }),
+            ...e.types
+          },
+          primaryType: e.primaryType,
+          message: e.message
+        };
+        return (await l({
+          evmAccount: n,
+          typedData: t
+        })).signature;
+      }
+    },
+    /**
+     * 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 A({
+        evmAccount: n,
+        hash: e.hash
+      })).signature;
+    }
+  });
 }
 export {
-  i as ModuleResolutionError
+  F as toViemAccount
 };

package/dist/esm/index.native100.js

@@ -1,13 +1,10 @@
-import { checkSigCryptoKey as i } from "./index.native108.js";
-import o from "./index.native101.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/index.native101.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 "./index.native109.js";
+import o from "./index.native102.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/index.native102.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/index.native103.js

@@ -1,19 +1,12 @@
-import n from "./index.native80.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/index.native104.js

@@ -1,83 +1,19 @@
-import { JOSENotSupported as s } from "./index.native29.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 "./index.native81.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/index.native105.js

@@ -1,15 +1,83 @@
-const s = {
-  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
-  l1Block: { address: "0x4200000000000000000000000000000000000015" },
-  l2CrossDomainMessenger: {
-    address: "0x4200000000000000000000000000000000000007"
-  },
-  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
-  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
-  l2ToL1MessagePasser: {
-    address: "0x4200000000000000000000000000000000000016"
+import { JOSENotSupported as s } from "./index.native30.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 {
-  s as contracts
+  i as default
 };