prettier

1 files changed, 113 insertions, 93 deletions

diff --git a/src/lib/nostr.js b/src/lib/nostr.js
index c2634c83..5ab87e51 100644
--- a/src/lib/nostr.js
+++ b/src/lib/nostr.js
@@ -1,144 +1,164 @@
-import { get } from 'svelte/store';
-import { Buffer } from 'buffer';
-import { fail, wait, post, stretch } from '$lib/utils';
-import { decrypted, password as pw, passwordPrompt, pin, loginRedirect } from '$lib/store';
-import { goto, invalidate } from '$app/navigation';
-import { getPublicKey, signEvent, getEventHash, nip04, nip06, nip19 } from 'nostr-tools';
-import { mnemonicToEntropy, entropyToMnemonic } from '@scure/bip39';
-import wordlist from '$lib/english';
-import { bech32m } from '@scure/base';
+import { get } from "svelte/store";
+import { Buffer } from "buffer";
+import { fail, wait, post, stretch } from "$lib/utils";
+import {
+  decrypted,
+  password as pw,
+  passwordPrompt,
+  pin,
+  loginRedirect,
+} from "$lib/store";
+import { goto, invalidate } from "$app/navigation";
+import {
+  getPublicKey,
+  signEvent,
+  getEventHash,
+  nip04,
+  nip06,
+  nip19,
+} from "nostr-tools";
+import { mnemonicToEntropy, entropyToMnemonic } from "@scure/bip39";
+import wordlist from "$lib/english";
+import { bech32m } from "@scure/base";
 
 const { generateSeedWords, privateKeyFromSeedWords } = nip06;
 const { encode, decode, toWords, fromWords } = bech32m;
 
 export let generate = async (user) => {
-	if (!get(pin)?.length === 6) return;
-	let password = get(pw);
+  if (!get(pin)?.length === 6) return;
+  let password = get(pw);
 
-	let salt = crypto.getRandomValues(new Uint8Array(16));
-	let mnemonic = generateSeedWords();
-	let sk = privateKeyFromSeedWords(mnemonic);
+  let salt = crypto.getRandomValues(new Uint8Array(16));
+  let mnemonic = generateSeedWords();
+  let sk = privateKeyFromSeedWords(mnemonic);
 
-	let bytes = new Uint8Array(
-		await crypto.subtle.encrypt(
-			{ name: 'AES-GCM', iv: new Uint8Array(16) },
-			await stretch(password, salt),
-			Uint8Array.from(Buffer.from(mnemonicToEntropy(mnemonic, wordlist), 'hex'))
-		)
-	);
+  let bytes = new Uint8Array(
+    await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv: new Uint8Array(16) },
+      await stretch(password, salt),
+      Uint8Array.from(Buffer.from(mnemonicToEntropy(mnemonic, wordlist), "hex"))
+    )
+  );
 
-	user.pubkey = getPublicKey(sk);
-	user.cipher = encode('en', toWords(bytes), 180);
-	user.salt = Buffer.from(salt).toString('hex');
+  user.pubkey = getPublicKey(sk);
+  user.cipher = encode("en", toWords(bytes), 180);
+  user.salt = Buffer.from(salt).toString("hex");
 };
 
 export let encrypt = async ({ message, recipient, user }) => {
-	return nip04.encrypt(await getPrivateKey(user), recipient, message);
+  return nip04.encrypt(await getPrivateKey(user), recipient, message);
 };
 
 export let decrypt = async ({ event, user }) => {
-	let cache = get(decrypted);
-	try {
-		let { content, pubkey, id } = event;
-		if (cache[id]) return cache[id];
-		if (pubkey === user.pubkey) pubkey = event.tags[0][1];
+  let cache = get(decrypted);
+  try {
+    let { content, pubkey, id } = event;
+    if (cache[id]) return cache[id];
+    if (pubkey === user.pubkey) pubkey = event.tags[0][1];
 
-		let message = await nip04.decrypt(await getPrivateKey(user), pubkey, content);
+    let message = await nip04.decrypt(
+      await getPrivateKey(user),
+      pubkey,
+      content
+    );
 
-		cache[id] = Buffer.from(message).toString('utf8');
-		decrypted.set(cache);
+    cache[id] = Buffer.from(message).toString("utf8");
+    decrypted.set(cache);
 
-		return cache[id];
-	} catch (e) {
-		// console.log(e);
-	}
+    return cache[id];
+  } catch (e) {
+    // console.log(e);
+  }
 };
 
 function typedArrayToBuffer(array) {
-	return array.buffer.slice(array.byteOffset, array.byteLength + array.byteOffset);
+  return array.buffer.slice(
+    array.byteOffset,
+    array.byteLength + array.byteOffset
+  );
 }
 
 export let getMnemonic = async (user) => {
-	let { cipher, username, salt } = user;
-	let password = get(pw);
+  let { cipher, username, salt } = user;
+  let password = get(pw);
 
-	if (!password) {
-		passwordPrompt.set(true);
-	}
+  if (!password) {
+    passwordPrompt.set(true);
+  }
 
-	try {
-		await post('/password', { password });
-	} catch (e) {
-		passwordPrompt.set(true);
-	}
+  try {
+    await post("/password", { password });
+  } catch (e) {
+    passwordPrompt.set(true);
+  }
 
-	await wait(() => !!get(pw));
-	password = get(pw);
+  await wait(() => !!get(pw));
+  password = get(pw);
 
-	let mnemonic, key, seed, entropy, child, privkey;
+  let mnemonic, key, seed, entropy, child, privkey;
 
-	entropy = new Uint8Array(
-		await crypto.subtle.decrypt(
-			{ name: 'AES-GCM', iv: new Uint8Array(16) },
-			await stretch(password, Buffer.from(salt, 'hex')),
-			Uint8Array.from(fromWords(decode(cipher, 180).words))
-		)
-	);
+  entropy = new Uint8Array(
+    await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: new Uint8Array(16) },
+      await stretch(password, Buffer.from(salt, "hex")),
+      Uint8Array.from(fromWords(decode(cipher, 180).words))
+    )
+  );
 
-	return entropyToMnemonic(entropy, wordlist);
+  return entropyToMnemonic(entropy, wordlist);
 };
 
 let getPrivateKey = async (user) => {
-	return privateKeyFromSeedWords(await getMnemonic(user));
+  return privateKeyFromSeedWords(await getMnemonic(user));
 };
 
 export let getNsec = async (user) => {
-	return nip19.nsecEncode(await getPrivateKey(user));
+  return nip19.nsecEncode(await getPrivateKey(user));
 };
 
 export let sign = async ({ event, user }) => {
-	event.id = getEventHash(event);
-	event.sig = signEvent(event, await getPrivateKey(user));
+  event.id = getEventHash(event);
+  event.sig = signEvent(event, await getPrivateKey(user));
 };
 
 export let send = (event) => {
-	return post('/events', { event });
+  return post("/events", { event });
 };
 
 export let reEncryptEntropy = async (user, newPassword) => {
-	let { cipher, username, salt } = user;
-	let password = get(pw);
+  let { cipher, username, salt } = user;
+  let password = get(pw);
 
-	if (!password) {
-		passwordPrompt.set(true);
-	}
+  if (!password) {
+    passwordPrompt.set(true);
+  }
 
-	try {
-		await post('/password', { password });
-	} catch (e) {
-		passwordPrompt.set(true);
-	}
+  try {
+    await post("/password", { password });
+  } catch (e) {
+    passwordPrompt.set(true);
+  }
 
-	await wait(() => !!get(pw));
-	password = get(pw);
+  await wait(() => !!get(pw));
+  password = get(pw);
 
-	let mnemonic, key, seed, entropy, child, privkey;
-	entropy = Buffer.from(
-		await crypto.subtle.decrypt(
-			{ name: 'AES-GCM', iv: new Uint8Array(16) },
-			await stretch(password, Buffer.from(salt, 'hex')),
-			Uint8Array.from(fromWords(decode(cipher, 180).words))
-		),
-		'hex'
-	).toString('hex');
+  let mnemonic, key, seed, entropy, child, privkey;
+  entropy = Buffer.from(
+    await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: new Uint8Array(16) },
+      await stretch(password, Buffer.from(salt, "hex")),
+      Uint8Array.from(fromWords(decode(cipher, 180).words))
+    ),
+    "hex"
+  ).toString("hex");
 
-	let bytes = new Uint8Array(
-		await crypto.subtle.encrypt(
-			{ name: 'AES-GCM', iv: new Uint8Array(16) },
-			await stretch(newPassword, Buffer.from(salt, 'hex')),
-			Uint8Array.from(Buffer.from(entropy, 'hex'))
-		)
-	);
+  let bytes = new Uint8Array(
+    await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv: new Uint8Array(16) },
+      await stretch(newPassword, Buffer.from(salt, "hex")),
+      Uint8Array.from(Buffer.from(entropy, "hex"))
+    )
+  );
 
-	return encode('en', toWords(bytes), 180);
+  return encode("en", toWords(bytes), 180);
 };