From: Chris Duncan <chris@zoso.dev>
Date: Sat, 30 Aug 2025 08:12:55 +0000 (-0700)
Subject: Formatting.
X-Git-Tag: v0.10.5~38^2~2
X-Git-Url: https://git.codecow.com/?a=commitdiff_plain;h=a1cd29c23503c92f237546c9e80776877c30479d;p=libnemo.git

Formatting.
---

diff --git a/src/lib/vault/vault-worker.ts b/src/lib/vault/vault-worker.ts
index 9be024a..f047ef0 100644
--- a/src/lib/vault/vault-worker.ts
+++ b/src/lib/vault/vault-worker.ts
@@ -25,75 +25,76 @@ export class VaultWorker {
 	static {
 		NODE: this.parentPort = parentPort
 		const listener = (message: MessageEvent<any>): Promise<void> => {
-			return this._extractData(message.data).then(extracted => {
-				const {
-					action,
-					type,
-					key,
-					keySalt,
-					iv,
-					seed,
-					mnemonicPhrase,
-					mnemonicSalt,
-					index,
-					encrypted,
-					data
-				} = extracted
-				let result: Promise<NamedData>
-				switch (action) {
-					case 'STOP': {
-						BROWSER: close()
-						NODE: process.exit()
-					}
-					case 'create': {
-						result = this.create(type, key, keySalt, mnemonicSalt)
-						break
-					}
-					case 'derive': {
-						result = this.derive(index)
-						break
-					}
-					case 'load': {
-						result = this.load(type, key, keySalt, mnemonicPhrase ?? seed, mnemonicSalt)
-						break
-					}
-					case 'lock': {
-						result = Promise.resolve(this.lock())
-						break
-					}
-					case 'sign': {
-						result = this.sign(index, data)
-						break
-					}
-					case 'unlock': {
-						result = this.unlock(type, key, iv, encrypted)
-						break
-					}
-					case 'update': {
-						result = this.update(key, keySalt)
-						break
-					}
-					case 'verify': {
-						result = Promise.resolve(this.verify(seed, mnemonicPhrase))
-						break
-					}
-					default: {
-						throw new Error(`Unknown wallet action '${action}'`)
-					}
-				}
-				return result.then(result => {
-					const transfer = []
-					for (const k of Object.keys(result)) {
-						if (result[k] instanceof ArrayBuffer || result[k] instanceof CryptoKey) {
-							transfer.push(result[k])
+			return this._extractData(message.data)
+				.then(extracted => {
+					const {
+						action,
+						type,
+						key,
+						keySalt,
+						iv,
+						seed,
+						mnemonicPhrase,
+						mnemonicSalt,
+						index,
+						encrypted,
+						data
+					} = extracted
+					let result: Promise<NamedData>
+					switch (action) {
+						case 'STOP': {
+							BROWSER: close()
+							NODE: process.exit()
+						}
+						case 'create': {
+							result = this.create(type, key, keySalt, mnemonicSalt)
+							break
+						}
+						case 'derive': {
+							result = this.derive(index)
+							break
+						}
+						case 'load': {
+							result = this.load(type, key, keySalt, mnemonicPhrase ?? seed, mnemonicSalt)
+							break
+						}
+						case 'lock': {
+							result = Promise.resolve(this.lock())
+							break
+						}
+						case 'sign': {
+							result = this.sign(index, data)
+							break
+						}
+						case 'unlock': {
+							result = this.unlock(type, key, iv, encrypted)
+							break
+						}
+						case 'update': {
+							result = this.update(key, keySalt)
+							break
+						}
+						case 'verify': {
+							result = Promise.resolve(this.verify(seed, mnemonicPhrase))
+							break
+						}
+						default: {
+							throw new Error(`Unknown wallet action '${action}'`)
 						}
 					}
-					//@ts-expect-error
-					BROWSER: postMessage(result, transfer)
-					//@ts-expect-error
-					NODE: parentPort?.postMessage(result, transfer)
+					return result.then(result => {
+						const transfer = []
+						for (const k of Object.keys(result)) {
+							if (result[k] instanceof ArrayBuffer || result[k] instanceof CryptoKey) {
+								transfer.push(result[k])
+							}
+						}
+						//@ts-expect-error
+						BROWSER: postMessage(result, transfer)
+						//@ts-expect-error
+						NODE: parentPort?.postMessage(result, transfer)
+					})
 				})
-			})
 				.catch((err: any) => {
 					console.error(err)
 					for (const key of Object.keys(message.data)) {
@@ -337,40 +338,37 @@ export class VaultWorker {
 	}
 
 	static _createAesKey (purpose: 'encrypt' | 'decrypt', keySalt: ArrayBuffer, password?: ArrayBuffer): Promise<CryptoKey | undefined> {
-		return new Promise((resolve, reject): void => {
-			if (password == null) {
-				resolve(undefined)
-				return
-			}
-			try {
-				crypto.subtle
-					.importKey('raw', password, 'PBKDF2', false, ['deriveKey'])
-					.then(derivationKey => {
-						new Uint8Array(password).fill(0).buffer.transfer?.()
-						const derivationAlgorithm: Pbkdf2Params = {
-							name: 'PBKDF2',
-							hash: 'SHA-512',
-							iterations: 210000,
-							salt: keySalt
-						}
-						const derivedKeyType: AesKeyGenParams = {
-							name: 'AES-GCM',
-							length: 256
-						}
-						crypto.subtle
-							.deriveKey(derivationAlgorithm, derivationKey, derivedKeyType, false, [purpose])
-							.then(resolve)
-					})
-			} catch (err) {
-				reject(err)
-			}
-		})
+		if (password == null) {
+			return Promise.resolve(undefined)
+		}
+		return crypto.subtle
+			.importKey('raw', password, 'PBKDF2', false, ['deriveKey'])
+			.then(derivationKey => {
+				new Uint8Array(password).fill(0).buffer.transfer?.()
+				const derivationAlgorithm: Pbkdf2Params = {
+					name: 'PBKDF2',
+					hash: 'SHA-512',
+					iterations: 210000,
+					salt: keySalt
+				}
+				const derivedKeyType: AesKeyGenParams = {
+					name: 'AES-GCM',
+					length: 256
+				}
+				return crypto.subtle
+					.deriveKey(derivationAlgorithm, derivationKey, derivedKeyType, false, [purpose])
+					.then(derivedKey => derivedKey)
+			})
+			.catch(err => {
+				throw new Error(err)
+			})
 	}
 
 	static _decryptWallet (type: string, key: CryptoKey, iv: ArrayBuffer, encrypted: ArrayBuffer): Promise<void> {
 		const seedLength = type === 'BIP-44' ? 64 : 32
 		const additionalData = utf8.toBytes(type)
-		return crypto.subtle.decrypt({ name: 'AES-GCM', iv, additionalData }, key, encrypted)
+		return crypto.subtle
+			.decrypt({ name: 'AES-GCM', iv, additionalData }, key, encrypted)
 			.then(decrypted => {
 				this.seed = decrypted.slice(0, seedLength)
 				this.mnemonic = decrypted.slice(seedLength)
@@ -412,7 +410,8 @@ export class VaultWorker {
 		const iv = crypto.getRandomValues(new Uint8Array(12)).buffer
 		const additionalData = utf8.toBytes(this.type)
 		const encoded = new Uint8Array([...seed, ...mnemonic])
-		return crypto.subtle.encrypt({ name: 'AES-GCM', iv, additionalData }, key, encoded)
+		return crypto.subtle
+			.encrypt({ name: 'AES-GCM', iv, additionalData }, key, encoded)
 			.then(encrypted => {
 				encoded.fill(0)
 				return { iv, encrypted }
@@ -635,9 +634,7 @@ export class VaultWorker {
 			return seed.then(seed => {
 				this.seed = seed
 				return this._encryptWallet(key)
-					.then(({ iv, encrypted }) => {
-						return { iv, salt: keySalt, encrypted }
-					})
+					.then(({ iv, encrypted }) => ({ iv, salt: keySalt, encrypted }))
 			})
 		} catch (err) {
 			throw new Error('Failed to load wallet', { cause: err })