chore: Fix lint reversion in common-identity (#512)

Author: jsantell

typescript/packages/common-identity/src/ed25519/index.ts

@@ -66,14 +66,14 @@ export class Ed25519Signer<ID extends DIDKey> implements Signer<ID> {
   static async generateMnemonic<ID extends DIDKey>(): Promise<
     [Ed25519Signer<ID>, string]
   > {
-    let mnemonic = bip39.generateMnemonic(wordlist, 256);
+    const mnemonic = bip39.generateMnemonic(wordlist, 256);
     return [await Ed25519Signer.fromMnemonic(mnemonic), mnemonic];
   }
 
   static async fromMnemonic<ID extends DIDKey>(
     mnemonic: string,
   ): Promise<Ed25519Signer<ID>> {
-    let bytes = bip39.mnemonicToEntropy(mnemonic, wordlist);
+    const bytes = bip39.mnemonicToEntropy(mnemonic, wordlist);
     return await Ed25519Signer.fromRaw(bytes);
   }
 

typescript/packages/common-identity/src/ed25519/native.ts

@@ -122,27 +122,27 @@ export class NativeEd25519Signer<ID extends DIDKey> implements Signer<ID> {
         "verify",
       ],
     );
-    let did = bytesToDid(new Uint8Array(rawPublic));
+    const did = bytesToDid(new Uint8Array(rawPublic));
     return new NativeEd25519Signer({ publicKey, privateKey }, did as ID);
   }
 
   static async generate<ID extends DIDKey>(): Promise<NativeEd25519Signer<ID>> {
     // This notably sets only the public key as extractable, ideal as we need
     // access to the public key for DID generation.
-    let keypair = await globalThis.crypto.subtle.generateKey(
+    const keypair = await globalThis.crypto.subtle.generateKey(
       ED25519_ALG,
       false,
       [
         "sign",
         "verify",
       ],
     );
-    let did = await didFromPublicKey(keypair.publicKey);
+    const did = await didFromPublicKey(keypair.publicKey);
     return new NativeEd25519Signer(keypair, did as ID);
   }
 
   static async deserialize<ID extends DIDKey>(keypair: CryptoKeyPair) {
-    let did = await didFromPublicKey(keypair.publicKey);
+    const did = await didFromPublicKey(keypair.publicKey);
     return new NativeEd25519Signer(keypair, did as ID);
   }
 }
@@ -179,14 +179,14 @@ export class NativeEd25519Verifier<ID extends DIDKey> implements Verifier<ID> {
   static async fromDid<ID extends DIDKey>(
     did: ID,
   ): Promise<NativeEd25519Verifier<ID>> {
-    let bytes = didToBytes(did);
+    const bytes = didToBytes(did);
     return await NativeEd25519Verifier.fromRaw(bytes);
   }
 
   static async fromRaw<ID extends DIDKey>(
     rawPublicKey: Uint8Array,
   ): Promise<NativeEd25519Verifier<ID>> {
-    let did = bytesToDid(new Uint8Array(rawPublicKey)) as ID;
+    const did = bytesToDid(new Uint8Array(rawPublicKey)) as ID;
     // Set the public key to be extractable for DID generation.
     const publicKey = await globalThis.crypto.subtle.importKey(
       "raw",
@@ -233,6 +233,6 @@ function ed25519RawToPkcs8(rawSignerKey: Uint8Array): Uint8Array {
 }
 
 async function didFromPublicKey(publicKey: CryptoKey): Promise<DIDKey> {
-  let rawPublicKey = await globalThis.crypto.subtle.exportKey("raw", publicKey);
+  const rawPublicKey = await globalThis.crypto.subtle.exportKey("raw", publicKey);
   return bytesToDid(new Uint8Array(rawPublicKey));
 }

typescript/packages/common-identity/src/ed25519/noble.ts

@@ -52,12 +52,12 @@ export class NobleEd25519Signer<ID extends DIDKey> implements Signer<ID> {
   }
 
   static async generate<ID extends DIDKey>(): Promise<NobleEd25519Signer<ID>> {
-    let privateKey = ed25519.utils.randomPrivateKey();
+    const privateKey = ed25519.utils.randomPrivateKey();
     return await NobleEd25519Signer.fromRaw(privateKey);
   }
 
-  static async deserialize<ID extends DIDKey>(keypair: InsecureCryptoKeyPair) {
-    return new NobleEd25519Signer<ID>(keypair);
+  static deserialize<ID extends DIDKey>(keypair: InsecureCryptoKeyPair) {
+    return Promise.resolve(new NobleEd25519Signer<ID>(keypair));
   }
 }
 
@@ -86,13 +86,13 @@ export class NobleEd25519Verifier<ID extends DIDKey> implements Verifier<ID> {
   static async fromDid<ID extends DIDKey>(
     did: ID,
   ): Promise<NobleEd25519Verifier<ID>> {
-    let bytes = didToBytes(did);
+    const bytes = didToBytes(did);
     return await NobleEd25519Verifier.fromRaw(bytes);
   }
 
-  static async fromRaw<ID extends DIDKey>(
+  static fromRaw<ID extends DIDKey>(
     rawPublicKey: Uint8Array,
   ): Promise<NobleEd25519Verifier<ID>> {
-    return new NobleEd25519Verifier(rawPublicKey);
+    return Promise.resolve(new NobleEd25519Verifier(rawPublicKey));
   }
 }

typescript/packages/common-identity/src/ed25519/utils.ts

@@ -43,7 +43,7 @@ export function ed25519RawToPkcs8(rawPrivateKey: Uint8Array): Uint8Array {
 
 // Convert public key bytes into a `did:key:z...`.
 export function bytesToDid(publicKey: Uint8Array): DIDKey {
-  let bytes = new Uint8Array(ED25519_PUB_KEY_TAGGED_SIZE);
+  const bytes = new Uint8Array(ED25519_PUB_KEY_TAGGED_SIZE);
   varint.encodeTo(ED25519_CODE, bytes);
   bytes.set(publicKey, ED25519_PUB_KEY_TAG_SIZE);
   return `did:key:${base58btc.encode(bytes)}`;

typescript/packages/common-identity/src/interface.ts

@@ -29,7 +29,7 @@ export interface Signature<Payload> extends Uint8Array {
   valueOf(): this & Signature<Payload>;
 }
 
-export type Unit = {};
+export type Unit = NonNullable<unknown>;
 
 export type Await<T> = PromiseLike<T> | T;
 export type AwaitResult<T extends Unit = Unit, E extends Error = Error> = Await<

typescript/packages/common-identity/test/ed25519.test.ts

@@ -145,11 +145,9 @@ function testBothImpls(
   fn: (signer: SignerClass, verifier: VerifierClass) => void | Promise<void>,
 ) {
   Deno.test(`(native) ${name}`, async () => {
-    // @ts-expect-error
     return await fn(NativeEd25519Signer, NativeEd25519Verifier);
   });
   Deno.test(`(noble) ${name}`, async () => {
-    // @ts-expect-error
     return await fn(NobleEd25519Signer, NobleEd25519Verifier);
   });
 }