Merge pull request #1558 from input-output-hk/feat/lw-12104-remove-async-from-crypto-interfaces

Author: AngelCastilloB

packages/cardano-services/src/StakePool/HttpStakePoolMetadata/HttpStakePoolMetadataService.ts

@@ -124,10 +124,10 @@ export const createHttpStakePoolMetadataService = (
           const signature = (await axiosClient.get<Crypto.Ed25519SignatureHex>(metadata.extSigUrl)).data;
           const message = HexBlob.fromBytes(Buffer.from(JSON.stringify(extMetadata)));
           const publicKey = Crypto.Ed25519PublicKeyHex(metadata.extVkey);
-          const bip32Ed25519 = new Crypto.SodiumBip32Ed25519();
+          const bip32Ed25519 = await Crypto.SodiumBip32Ed25519.create();
 
           // Verify the signature
-          const isSignatureValid = await bip32Ed25519.verify(signature, message, publicKey);
+          const isSignatureValid = bip32Ed25519.verify(signature, message, publicKey);
 
           // If not valid -> omit extended metadata from response and add specific error
           if (!isSignatureValid) {

packages/core/test/Cardano/util/computeImplicitCoin.test.ts

@@ -7,14 +7,16 @@ describe('Cardano.util.computeImplicitCoin', () => {
   let dRepPublicKey: Crypto.Ed25519PublicKeyHex;
   let dRepKeyHash: Crypto.Ed25519KeyHashHex;
 
+  beforeAll(() => Crypto.ready());
+
   beforeEach(async () => {
     rewardAccount = Cardano.RewardAccount('stake_test1uqfu74w3wh4gfzu8m6e7j987h4lq9r3t7ef5gaw497uu85qsqfy27');
     stakeCredential = {
       hash: Cardano.RewardAccount.toHash(rewardAccount) as unknown as Crypto.Hash28ByteBase16,
       type: Cardano.CredentialType.KeyHash
     };
     dRepPublicKey = Crypto.Ed25519PublicKeyHex('deeb8f82f2af5836ebbc1b450b6dbf0b03c93afe5696f10d49e8a8304ebfac01');
-    dRepKeyHash = (await Crypto.Ed25519PublicKey.fromHex(dRepPublicKey).hash()).hex();
+    dRepKeyHash = Crypto.Ed25519PublicKey.fromHex(dRepPublicKey).hash().hex();
   });
 
   describe('calculates deposit', () => {

packages/crypto/src/Bip32/Bip32PrivateKey.ts

@@ -71,6 +71,8 @@ export class Bip32PrivateKey {
    *   - 32 bytes: Ed25519 curve scalar from which few bits have been tweaked according to ED25519-BIP32
    *   - 32 bytes: Ed25519 binary blob used as IV for signing
    *
+   * NOTE: You must await `Crypto.ready()` at least once before calling this function.
+   *
    * @param entropy Random stream of bytes generated from a BIP39 seed phrase.
    * @param password The second factor authentication password for the mnemonic phrase.
    * @returns The secret extended key.
@@ -123,11 +125,12 @@ export class Bip32PrivateKey {
    * This is why deriving the private key should not fail while deriving
    * the public key may fail (if the derivation index is invalid).
    *
+   * NOTE: You must await `Crypto.ready()` at least once before calling this function.
+   *
    * @param derivationIndices The derivation indices.
    * @returns The child BIP-32 key.
    */
-  async derive(derivationIndices: number[]): Promise<Bip32PrivateKey> {
-    await sodium.ready;
+  derive(derivationIndices: number[]): Bip32PrivateKey {
     let key = Buffer.from(this.#key);
 
     for (const index of derivationIndices) {
@@ -145,10 +148,11 @@ export class Bip32PrivateKey {
   /**
    * Computes the BIP-32 public key from this BIP-32 private key.
    *
+   * NOTE: You must await `Crypto.ready()` at least once before calling this function.
+   *
    * @returns the public key.
    */
-  async toPublic(): Promise<Bip32PublicKey> {
-    await sodium.ready;
+  toPublic(): Bip32PublicKey {
     const scalar = extendedScalar(this.#key.slice(0, EXTENDED_ED25519_PRIVATE_KEY_LENGTH));
     const publicKey = sodium.crypto_scalarmult_ed25519_base_noclamp(scalar);
 

packages/crypto/src/Bip32/Bip32PublicKey.ts

@@ -53,11 +53,12 @@ export class Bip32PublicKey {
   /**
    * Given a set of indices, this function computes the corresponding child extended key.
    *
+   * NOTE: You must await `Crypto.ready()` at least once before calling this function.
+   *
    * @param derivationIndices The list of derivation indices.
    * @returns The child extended private key.
    */
-  async derive(derivationIndices: number[]): Promise<Bip32PublicKey> {
-    await sodium.ready;
+  derive(derivationIndices: number[]): Bip32PublicKey {
     let key = Buffer.from(this.#key);
 
     for (const index of derivationIndices) {
@@ -77,9 +78,8 @@ export class Bip32PublicKey {
     return Bip32PublicKeyHex(Buffer.from(this.#key).toString('hex'));
   }
 
-  /** Gets the blake2 hash of the key. */
-  async hash(): Promise<Bip32PublicKeyHashHex> {
-    await sodium.ready;
+  /** Gets the blake2 hash of the key. NOTE: You must await `Crypto.ready()` at least once before calling this function. */
+  hash(): Bip32PublicKeyHashHex {
     const hash = sodium.crypto_generichash(BIP32_PUBLIC_KEY_HASH_LENGTH, this.#key);
     return Bip32PublicKeyHashHex(Buffer.from(hash).toString('hex'));
   }

packages/crypto/src/Bip32Ed25519.ts

@@ -37,32 +37,32 @@ export interface Bip32Ed25519 {
    * @param privateKey The private key to generate the public key from.
    * @returns The matching public key.
    */
-  getPublicKey(privateKey: Ed25519PrivateExtendedKeyHex | Ed25519PrivateNormalKeyHex): Promise<Ed25519PublicKeyHex>;
+  getPublicKey(privateKey: Ed25519PrivateExtendedKeyHex | Ed25519PrivateNormalKeyHex): Ed25519PublicKeyHex;
 
   /**
    * Computes the hash of the given public key.
    *
    * @param publicKey The public key to compute the hash from.
    * @returns The public key hash.
    */
-  getPubKeyHash(publicKey: Ed25519PublicKeyHex): Promise<Ed25519KeyHashHex>;
+  getPubKeyHash(publicKey: Ed25519PublicKeyHex): Ed25519KeyHashHex;
 
   /** Gets the Ed25519 raw private key. This key can be used for cryptographically signing messages. */
-  getRawPrivateKey(bip32PrivateKey: Bip32PrivateKeyHex): Promise<Ed25519PrivateExtendedKeyHex>;
+  getRawPrivateKey(bip32PrivateKey: Bip32PrivateKeyHex): Ed25519PrivateExtendedKeyHex;
 
   /**
    * Gets the Ed25519 raw public key. This key can be used for cryptographically verifying messages
    * previously signed with the matching Ed25519 raw private key.
    */
-  getRawPublicKey(bip32PublicKey: Bip32PublicKeyHex): Promise<Ed25519PublicKeyHex>;
+  getRawPublicKey(bip32PublicKey: Bip32PublicKeyHex): Ed25519PublicKeyHex;
 
   /**
    * The function computes the BIP-32 public key from the provided BIP-32 private key.
    *
    * @param privateKey The extended private key to generate the public key from.
    * @returns The extended public key.
    */
-  getBip32PublicKey(privateKey: Bip32PrivateKeyHex): Promise<Bip32PublicKeyHex>;
+  getBip32PublicKey(privateKey: Bip32PrivateKeyHex): Bip32PublicKeyHex;
 
   /**
    * Given a parent extended key and a set of indices, this function computes the corresponding child extended key.
@@ -71,7 +71,7 @@ export interface Bip32Ed25519 {
    * @param derivationIndices The list of derivation indices.
    * @returns The child extended private key.
    */
-  derivePrivateKey(parentKey: Bip32PrivateKeyHex, derivationIndices: BIP32Path): Promise<Bip32PrivateKeyHex>;
+  derivePrivateKey(parentKey: Bip32PrivateKeyHex, derivationIndices: BIP32Path): Bip32PrivateKeyHex;
 
   /**
    * Given a parent extended key and a set of indices, this function computes the corresponding child extended key.
@@ -80,7 +80,7 @@ export interface Bip32Ed25519 {
    * @param derivationIndices The list of derivation indices.
    * @returns The child extended public key.
    */
-  derivePublicKey(parentKey: Bip32PublicKeyHex, derivationIndices: BIP32Path): Promise<Bip32PublicKeyHex>;
+  derivePublicKey(parentKey: Bip32PublicKeyHex, derivationIndices: BIP32Path): Bip32PublicKeyHex;
 
   /**
    * Generates an Ed25519 signature using an extended private key.
@@ -89,10 +89,7 @@ export interface Bip32Ed25519 {
    * @param message The message to be signed.
    * @returns The Ed25519 digital signature.
    */
-  sign(
-    privateKey: Ed25519PrivateExtendedKeyHex | Ed25519PrivateNormalKeyHex,
-    message: HexBlob
-  ): Promise<Ed25519SignatureHex>;
+  sign(privateKey: Ed25519PrivateExtendedKeyHex | Ed25519PrivateNormalKeyHex, message: HexBlob): Ed25519SignatureHex;
 
   /**
    * Verifies that the passed-in signature was generated with a extended private key that matches
@@ -103,5 +100,5 @@ export interface Bip32Ed25519 {
    * @param publicKey The Ed25519 public key that validates the given signature.
    * @returns true if the signature is valid; otherwise; false.
    */
-  verify(signature: Ed25519SignatureHex, message: HexBlob, publicKey: Ed25519PublicKeyHex): Promise<boolean>;
+  verify(signature: Ed25519SignatureHex, message: HexBlob, publicKey: Ed25519PublicKeyHex): boolean;
 }

packages/crypto/src/Ed25519e/Ed25519PrivateKey.ts

@@ -78,11 +78,11 @@ export class Ed25519PrivateKey {
   /**
    * Computes the raw public key from this raw private key.
    *
+   * NOTE: You must await `Crypto.ready()` at least once before calling this function.
+   *
    * @returns the public key.
    */
-  async toPublic(): Promise<Ed25519PublicKey> {
-    await sodium.ready;
-
+  toPublic(): Ed25519PublicKey {
     return Ed25519PublicKey.fromBytes(
       this.__type === Ed25519PrivateKeyType.Extended
         ? sodium.crypto_scalarmult_ed25519_base_noclamp(extendedScalar(this.#keyMaterial))
@@ -93,17 +93,18 @@ export class Ed25519PrivateKey {
   /**
    * Generates an Ed25519 signature.
    *
+   * NOTE: You must await `Crypto.ready()` at least once before calling this function.
+   *
    * @param message The message to be signed.
    * @returns The Ed25519 digital signature.
    */
-  async sign(message: HexBlob): Promise<Ed25519Signature> {
-    await sodium.ready;
+  sign(message: HexBlob): Ed25519Signature {
     return Ed25519Signature.fromBytes(
       this.__type === Ed25519PrivateKeyType.Extended
         ? signExtendedDetached(this.#keyMaterial, Buffer.from(message, 'hex'))
         : sodium.crypto_sign_detached(
             Buffer.from(message, 'hex'),
-            Buffer.concat([this.#keyMaterial, (await this.toPublic()).bytes()])
+            Buffer.concat([this.#keyMaterial, this.toPublic().bytes()])
           )
     );
   }

packages/crypto/src/Ed25519e/Ed25519PublicKey.ts

@@ -26,12 +26,13 @@ export class Ed25519PublicKey {
    * Verifies that the passed-in signature was generated with a private key that matches
    * the given public key.
    *
+   * NOTE: You must await `Crypto.ready()` at least once before calling this function.
+   *
    * @param signature The signature bytes to be verified.
    * @param message The original message the signature was computed from.
    * @returns true if the signature is valid; otherwise; false.
    */
-  async verify(signature: Ed25519Signature, message: HexBlob): Promise<boolean> {
-    await sodium.ready;
+  verify(signature: Ed25519Signature, message: HexBlob): boolean {
     return sodium.crypto_sign_verify_detached(signature.bytes(), Buffer.from(message, 'hex'), this.#keyMaterial);
   }
 
@@ -58,9 +59,8 @@ export class Ed25519PublicKey {
     return Ed25519PublicKey.fromBytes(Buffer.from(keyMaterial, 'hex'));
   }
 
-  /** Gets the blake2 hash of the key material. */
-  async hash(): Promise<Ed25519KeyHash> {
-    await sodium.ready;
+  /** Gets the blake2 hash of the key material. NOTE: You must await `Crypto.ready()` at least once before calling this function. */
+  hash(): Ed25519KeyHash {
     const hash = sodium.crypto_generichash(ED25519_PUBLIC_KEY_HASH_LENGTH, this.#keyMaterial);
     return Ed25519KeyHash.fromBytes(hash);
   }

packages/crypto/src/index.ts

@@ -1,4 +1,5 @@
 import blake2b from 'blake2b';
+import sodium from 'libsodium-wrappers-sumo';
 export { blake2b };
 
 export * from './Bip32';
@@ -7,3 +8,6 @@ export * from './Ed25519e';
 export * from './strategies';
 export * from './hexTypes';
 export * from './types';
+
+/** This function must be awaited before calling any other function in this module. It is safe to await this function multiple times. */
+export const ready = async (): Promise<void> => await sodium.ready;

packages/crypto/src/strategies/CmlBip32Ed25519.ts

@@ -30,9 +30,7 @@ export class CmlBip32Ed25519 implements Bip32Ed25519 {
     return Bip32PrivateKeyHex(Buffer.from(hexKey).toString('hex'));
   }
 
-  public getPublicKey(
-    privateKey: Ed25519PrivateExtendedKeyHex | Ed25519PrivateNormalKeyHex
-  ): Promise<Ed25519PublicKeyHex> {
+  public getPublicKey(privateKey: Ed25519PrivateExtendedKeyHex | Ed25519PrivateNormalKeyHex): Ed25519PublicKeyHex {
     return usingAutoFree((scope) => {
       const cmlPrivateKey =
         privateKey.length === EXTENDED_KEY_HEX_LENGTH
@@ -41,90 +39,86 @@ export class CmlBip32Ed25519 implements Bip32Ed25519 {
 
       const pubKeyBytes = scope.manage(cmlPrivateKey.to_public()).as_bytes();
 
-      return Promise.resolve(Ed25519PublicKeyHex(Buffer.from(pubKeyBytes).toString('hex')));
+      return Ed25519PublicKeyHex(Buffer.from(pubKeyBytes).toString('hex'));
     });
   }
 
-  public getPubKeyHash(publicKey: Ed25519PublicKeyHex): Promise<Ed25519KeyHashHex> {
+  public getPubKeyHash(publicKey: Ed25519PublicKeyHex): Ed25519KeyHashHex {
     return usingAutoFree((scope) => {
       const cmlPubKey = scope.manage(this.#CML.PublicKey.from_bytes(Buffer.from(publicKey, 'hex')));
       const keyHash = scope.manage(cmlPubKey.hash()).to_bytes();
 
-      return Promise.resolve(Ed25519KeyHashHex(Buffer.from(keyHash).toString('hex')));
+      return Ed25519KeyHashHex(Buffer.from(keyHash).toString('hex'));
     });
   }
 
-  public getRawPrivateKey(bip32PrivateKey: Bip32PrivateKeyHex): Promise<Ed25519PrivateExtendedKeyHex> {
+  public getRawPrivateKey(bip32PrivateKey: Bip32PrivateKeyHex): Ed25519PrivateExtendedKeyHex {
     return usingAutoFree((scope) => {
       const cmlPrivateKey = scope.manage(this.#CML.Bip32PrivateKey.from_bytes(Buffer.from(bip32PrivateKey, 'hex')));
       const bytes = scope.manage(cmlPrivateKey.to_raw_key()).as_bytes();
-      return Promise.resolve(Ed25519PrivateExtendedKeyHex(Buffer.from(bytes).toString('hex')));
+      return Ed25519PrivateExtendedKeyHex(Buffer.from(bytes).toString('hex'));
     });
   }
 
-  public getRawPublicKey(bip32PublicKey: Bip32PublicKeyHex): Promise<Ed25519PublicKeyHex> {
+  public getRawPublicKey(bip32PublicKey: Bip32PublicKeyHex): Ed25519PublicKeyHex {
     return usingAutoFree((scope) => {
       const cmlPublicKey = scope.manage(this.#CML.Bip32PublicKey.from_bytes(Buffer.from(bip32PublicKey, 'hex')));
       const bytes = scope.manage(cmlPublicKey.to_raw_key()).as_bytes();
-      return Promise.resolve(Ed25519PublicKeyHex(Buffer.from(bytes).toString('hex')));
+      return Ed25519PublicKeyHex(Buffer.from(bytes).toString('hex'));
     });
   }
 
-  public getBip32PublicKey(privateKey: Bip32PrivateKeyHex): Promise<Bip32PublicKeyHex> {
+  public getBip32PublicKey(privateKey: Bip32PrivateKeyHex): Bip32PublicKeyHex {
     return usingAutoFree((scope) => {
       const cmlPrivateKey = scope.manage(this.#CML.Bip32PrivateKey.from_bytes(Buffer.from(privateKey, 'hex')));
       const pubKeyBytes = scope.manage(cmlPrivateKey.to_public()).as_bytes();
-      return Promise.resolve(Bip32PublicKeyHex(Buffer.from(pubKeyBytes).toString('hex')));
+      return Bip32PublicKeyHex(Buffer.from(pubKeyBytes).toString('hex'));
     });
   }
 
-  public derivePrivateKey(parentKey: Bip32PrivateKeyHex, derivationIndices: BIP32Path): Promise<Bip32PrivateKeyHex> {
+  public derivePrivateKey(parentKey: Bip32PrivateKeyHex, derivationIndices: BIP32Path): Bip32PrivateKeyHex {
     return usingAutoFree((scope) => {
       let cmlKey = scope.manage(this.#CML.Bip32PrivateKey.from_bytes(Buffer.from(parentKey, 'hex')));
 
       for (const index of derivationIndices) {
         cmlKey = scope.manage(cmlKey.derive(index));
       }
 
-      return Promise.resolve(Bip32PrivateKeyHex(Buffer.from(cmlKey.as_bytes()).toString('hex')));
+      return Bip32PrivateKeyHex(Buffer.from(cmlKey.as_bytes()).toString('hex'));
     });
   }
 
-  public derivePublicKey(parentKey: Bip32PublicKeyHex, derivationIndices: BIP32Path): Promise<Bip32PublicKeyHex> {
+  public derivePublicKey(parentKey: Bip32PublicKeyHex, derivationIndices: BIP32Path): Bip32PublicKeyHex {
     return usingAutoFree((scope) => {
       let cmlKey = scope.manage(this.#CML.Bip32PublicKey.from_bytes(Buffer.from(parentKey, 'hex')));
 
       for (const index of derivationIndices) {
         cmlKey = scope.manage(cmlKey.derive(index));
       }
 
-      return Promise.resolve(Bip32PublicKeyHex(Buffer.from(cmlKey.as_bytes()).toString('hex')));
+      return Bip32PublicKeyHex(Buffer.from(cmlKey.as_bytes()).toString('hex'));
     });
   }
 
-  public async sign(
+  public sign(
     privateKey: Ed25519PrivateExtendedKeyHex | Ed25519PrivateNormalKeyHex,
     message: HexBlob
-  ): Promise<Ed25519SignatureHex> {
+  ): Ed25519SignatureHex {
     return usingAutoFree((scope) => {
       const cmlPrivateKey =
         privateKey.length === EXTENDED_KEY_HEX_LENGTH
           ? scope.manage(this.#CML.PrivateKey.from_extended_bytes(Buffer.from(privateKey, 'hex')))
           : scope.manage(this.#CML.PrivateKey.from_normal_bytes(Buffer.from(privateKey, 'hex')));
       const signature = scope.manage(cmlPrivateKey.sign(Buffer.from(message, 'hex'))).to_bytes();
-      return Promise.resolve(Ed25519SignatureHex(Buffer.from(signature).toString('hex')));
+      return Ed25519SignatureHex(Buffer.from(signature).toString('hex'));
     });
   }
 
-  public async verify(
-    signature: Ed25519SignatureHex,
-    message: HexBlob,
-    publicKey: Ed25519PublicKeyHex
-  ): Promise<boolean> {
+  public verify(signature: Ed25519SignatureHex, message: HexBlob, publicKey: Ed25519PublicKeyHex): boolean {
     return usingAutoFree((scope) => {
       const cmlKey = scope.manage(this.#CML.PublicKey.from_bytes(Buffer.from(publicKey, 'hex')));
       const cmlSignature = scope.manage(this.#CML.Ed25519Signature.from_bytes(Buffer.from(signature, 'hex')));
-      return Promise.resolve(cmlKey.verify(Buffer.from(message, 'hex'), cmlSignature));
+      return cmlKey.verify(Buffer.from(message, 'hex'), cmlSignature);
     });
   }
 }