refactor!: remove unnecessary async from crypto methods

packages/crypto/src/aes/index.ts

@@ -51,7 +51,7 @@ export interface AESCipher {
  * @param key - The key, if length `16` then `AES 128` is used. For length `32`, `AES 256` is used
  * @param iv - Must have length `16`
  */
-export async function create (key: Uint8Array, iv: Uint8Array): Promise<AESCipher> {
+export function create (key: Uint8Array, iv: Uint8Array): AESCipher {
   const mode = cipherMode(key)
   const cipher = ciphers.createCipheriv(mode, key, iv)
   const decipher = ciphers.createDecipheriv(mode, key, iv)

packages/crypto/src/ciphers/aes-gcm.ts

@@ -14,7 +14,7 @@ export function create (opts?: CreateOptions): AESCipher {
   const iterations = opts?.iterations ?? 32767
   const algorithmTagLength = opts?.algorithmTagLength ?? 16
 
-  async function encryptWithKey (data: Uint8Array, key: Uint8Array): Promise<Uint8Array> {
+  function encryptWithKey (data: Uint8Array, key: Uint8Array): Uint8Array {
     const nonce = crypto.randomBytes(nonceLength)
 
     // Create the cipher instance.
@@ -43,7 +43,7 @@ export function create (opts?: CreateOptions): AESCipher {
     const key = crypto.pbkdf2Sync(password, salt, iterations, keyLength, digest)
 
     // Encrypt and prepend salt.
-    return uint8ArrayConcat([salt, await encryptWithKey(Uint8Array.from(data), key)])
+    return uint8ArrayConcat([salt, encryptWithKey(Uint8Array.from(data), key)])
   }
 
   /**
@@ -53,7 +53,7 @@ export function create (opts?: CreateOptions): AESCipher {
    * this decryption cipher must be the same as those used to create
    * the encryption cipher.
    */
-  async function decryptWithKey (ciphertextAndNonce: Uint8Array, key: Uint8Array): Promise<Uint8Array> {
+  function decryptWithKey (ciphertextAndNonce: Uint8Array, key: Uint8Array): Uint8Array {
     // Create Uint8Arrays of nonce, ciphertext and tag.
     const nonce = ciphertextAndNonce.subarray(0, nonceLength)
     const ciphertext = ciphertextAndNonce.subarray(nonceLength, ciphertextAndNonce.length - algorithmTagLength)

packages/crypto/src/keys/ed25519-browser.ts

@@ -9,7 +9,7 @@ const KEYS_BYTE_LENGTH = 32
 export { PUBLIC_KEY_BYTE_LENGTH as publicKeyLength }
 export { PRIVATE_KEY_BYTE_LENGTH as privateKeyLength }
 
-export async function generateKey (): Promise<Uint8ArrayKeyPair> {
+export function generateKey (): Uint8ArrayKeyPair {
   // the actual private key (32 bytes)
   const privateKeyRaw = ed.utils.randomPrivateKey()
   const publicKey = ed.getPublicKey(privateKeyRaw)
@@ -26,7 +26,7 @@ export async function generateKey (): Promise<Uint8ArrayKeyPair> {
 /**
  * Generate keypair from a 32 byte uint8array
  */
-export async function generateKeyFromSeed (seed: Uint8Array): Promise<Uint8ArrayKeyPair> {
+export function generateKeyFromSeed (seed: Uint8Array): Uint8ArrayKeyPair {
   if (seed.length !== KEYS_BYTE_LENGTH) {
     throw new TypeError('"seed" must be 32 bytes in length.')
   } else if (!(seed instanceof Uint8Array)) {
@@ -45,13 +45,13 @@ export async function generateKeyFromSeed (seed: Uint8Array): Promise<Uint8Array
   }
 }
 
-export async function hashAndSign (privateKey: Uint8Array, msg: Uint8Array | Uint8ArrayList): Promise<Uint8Array> {
+export function hashAndSign (privateKey: Uint8Array, msg: Uint8Array | Uint8ArrayList): Uint8Array {
   const privateKeyRaw = privateKey.subarray(0, KEYS_BYTE_LENGTH)
 
   return ed.sign(msg instanceof Uint8Array ? msg : msg.subarray(), privateKeyRaw)
 }
 
-export async function hashAndVerify (publicKey: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): Promise<boolean> {
+export function hashAndVerify (publicKey: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): boolean {
   return ed.verify(sig, msg instanceof Uint8Array ? msg : msg.subarray(), publicKey)
 }
 

packages/crypto/src/keys/ed25519-class.ts

@@ -129,12 +129,12 @@ export function unmarshalEd25519PublicKey (bytes: Uint8Array): Ed25519PublicKey
 }
 
 export async function generateKeyPair (): Promise<Ed25519PrivateKey> {
-  const { privateKey, publicKey } = await crypto.generateKey()
+  const { privateKey, publicKey } = crypto.generateKey()
   return new Ed25519PrivateKey(privateKey, publicKey)
 }
 
 export async function generateKeyPairFromSeed (seed: Uint8Array): Promise<Ed25519PrivateKey> {
-  const { privateKey, publicKey } = await crypto.generateKeyFromSeed(seed)
+  const { privateKey, publicKey } = crypto.generateKeyFromSeed(seed)
   return new Ed25519PrivateKey(privateKey, publicKey)
 }
 

packages/crypto/src/keys/ed25519.ts

@@ -1,12 +1,11 @@
 import crypto from 'crypto'
-import { promisify } from 'util'
 import { concat as uint8arrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8arrayToString } from 'uint8arrays/to-string'
 import type { Uint8ArrayKeyPair } from './interface.js'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-const keypair = promisify(crypto.generateKeyPair)
+const keypair = crypto.generateKeyPairSync
 
 const PUBLIC_KEY_BYTE_LENGTH = 32
 const PRIVATE_KEY_BYTE_LENGTH = 64 // private key is actually 32 bytes but for historical reasons we concat private and public keys
@@ -37,8 +36,8 @@ function derivePublicKey (privateKey: Uint8Array): Uint8Array {
   return uint8arrayFromString(jwk.x, 'base64url')
 }
 
-export async function generateKey (): Promise<Uint8ArrayKeyPair> {
-  const key = await keypair('ed25519', {
+export function generateKey (): Uint8ArrayKeyPair {
+  const key = keypair('ed25519', {
     publicKeyEncoding: { type: 'spki', format: 'jwk' },
     privateKeyEncoding: { type: 'pkcs8', format: 'jwk' }
   })
@@ -57,7 +56,7 @@ export async function generateKey (): Promise<Uint8ArrayKeyPair> {
 /**
  * Generate keypair from a 32 byte uint8array
  */
-export async function generateKeyFromSeed (seed: Uint8Array): Promise<Uint8ArrayKeyPair> {
+export function generateKeyFromSeed (seed: Uint8Array): Uint8ArrayKeyPair {
   if (seed.length !== KEYS_BYTE_LENGTH) {
     throw new TypeError('"seed" must be 32 bytes in length.')
   } else if (!(seed instanceof Uint8Array)) {
@@ -73,7 +72,7 @@ export async function generateKeyFromSeed (seed: Uint8Array): Promise<Uint8Array
   }
 }
 
-export async function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList): Promise<Buffer> {
+export function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList): Buffer {
   if (!(key instanceof Uint8Array)) {
     throw new TypeError('"key" must be a node.js Buffer, or Uint8Array.')
   }
@@ -104,7 +103,7 @@ export async function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8Array
   return crypto.sign(null, msg instanceof Uint8Array ? msg : msg.subarray(), obj)
 }
 
-export async function hashAndVerify (key: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): Promise<boolean> {
+export function hashAndVerify (key: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): boolean {
   if (key.byteLength !== PUBLIC_KEY_BYTE_LENGTH) {
     throw new TypeError('"key" must be 32 bytes in length.')
   } else if (!(key instanceof Uint8Array)) {

packages/crypto/test/aes/aes.spec.ts

@@ -24,7 +24,7 @@ describe('AES-CTR', () => {
       const iv = new Uint8Array(16)
       iv.fill(1)
 
-      const cipher = await crypto.aes.create(key, iv)
+      const cipher = crypto.aes.create(key, iv)
 
       await encryptAndDecrypt(cipher)
       await encryptAndDecrypt(cipher)
@@ -42,7 +42,7 @@ describe('AES-CTR', () => {
       const iv = new Uint8Array(16)
       iv.fill(1)
 
-      const cipher = await crypto.aes.create(key, iv)
+      const cipher = crypto.aes.create(key, iv)
       // @ts-expect-error cannot index fixtures like this
       const fixture = fixtures[length]
 
@@ -71,7 +71,7 @@ describe('AES-CTR', () => {
       const iv = new Uint8Array(16)
       iv.fill(1)
 
-      const cipher = await crypto.aes.create(key, iv)
+      const cipher = crypto.aes.create(key, iv)
       // @ts-expect-error cannot index fixtures like this
       const fixture = goFixtures[length]
 
@@ -90,7 +90,7 @@ describe('AES-CTR', () => {
   it('checks key length', () => {
     const key = new Uint8Array(5)
     const iv = new Uint8Array(16)
-    return expect(crypto.aes.create(key, iv)).to.eventually.be.rejected.with.property('code', 'ERR_INVALID_KEY_LENGTH')
+    return expect(() => crypto.aes.create(key, iv)).to.throw().with.property('code', 'ERR_INVALID_KEY_LENGTH')
   })
 })