@libp2p/crypto 2.0.8-4a474d54d → 2.0.8-68db79f6b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/crypto",
-  "version": "2.0.8-4a474d54d",
+  "version": "2.0.8-68db79f6b",
   "description": "Crypto primitives for libp2p",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/crypto#readme",
@@ -11,6 +11,10 @@
   "bugs": {
     "url": "https://github.com/libp2p/js-libp2p/issues"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "keywords": [
     "IPFS",
     "crypto",
@@ -86,7 +90,7 @@
     "generate": "protons ./src/keys/keys.proto"
   },
   "dependencies": {
-    "@libp2p/interface": "0.1.6-4a474d54d",
+    "@libp2p/interface": "0.1.6-68db79f6b",
     "@noble/curves": "^1.1.0",
     "@noble/hashes": "^1.3.1",
     "multiformats": "^12.1.3",

package/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)

package/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)

package/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)
 }
 

package/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)
 }
 

package/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)) {