biome format

1 files changed, 96 insertions, 96 deletions

diff --git a/src/lib/nostr.ts b/src/lib/nostr.ts
index a9926ba1..a00a28f9 100644
--- a/src/lib/nostr.ts
+++ b/src/lib/nostr.ts
@@ -5,16 +5,16 @@ import { Buffer } from "buffer";
 import { wait, post, stretch } from "$lib/utils";
 import { decrypted, password as pw, passwordPrompt, pin } from "$lib/store";
 import {
-  getPublicKey,
-  finalizeEvent,
-  nip04,
-  nip19,
-  type EventTemplate,
+	getPublicKey,
+	finalizeEvent,
+	nip04,
+	nip19,
+	type EventTemplate,
 } from "nostr-tools";
 
 import {
-  encrypt as nip49encrypt,
-  decrypt as nip49decrypt,
+	encrypt as nip49encrypt,
+	decrypt as nip49decrypt,
 } from "nostr-tools/nip49";
 
 import { mnemonicToEntropy, entropyToMnemonic } from "@scure/bip39";
@@ -24,154 +24,154 @@ import { wordlist } from "@scure/bip39/wordlists/english";
 import { generateSeedWords, privateKeyFromSeedWords } from "nostr-tools/nip06";
 
 type User = {
-  [key: string]: any;
+	[key: string]: any;
 };
 
 type EncryptParams = {
-  message: string;
-  recipient: string;
-  user: User;
+	message: string;
+	recipient: string;
+	user: User;
 };
 
 const { encode, decode, toWords, fromWords } = bech32m;
 
 export let generate = async (user: any) => {
-  let p = get(pin);
-  if (p && p.length !== 6) return;
+	let p = get(pin);
+	if (p && p.length !== 6) return;
 
-  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(await getPassword(), salt),
-      mnemonicToEntropy(mnemonic, wordlist)
-    )
-  );
+	let bytes = new Uint8Array(
+		await crypto.subtle.encrypt(
+			{ name: "AES-GCM", iv: new Uint8Array(16) },
+			await stretch(await getPassword(), salt),
+			mnemonicToEntropy(mnemonic, wordlist),
+		),
+	);
 
-  user.pubkey = getPublicKey(hexToUint8Array(sk));
-  user.cipher = encode("en", toWords(bytes), 180);
-  user.salt = Buffer.from(salt).toString("hex");
+	user.pubkey = getPublicKey(hexToUint8Array(sk));
+	user.cipher = encode("en", toWords(bytes), 180);
+	user.salt = Buffer.from(salt).toString("hex");
 };
 
 export let encrypt = async ({ message, recipient, user }: EncryptParams) => {
-  let sk = await getPrivateKey(user);
-  return nip04.encrypt(sk, recipient, message);
+	let sk = await getPrivateKey(user);
+	return nip04.encrypt(sk, 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);
+	}
 };
 
 export let getPrivateKey = async (user: User): Promise<Uint8Array> => {
-  let k;
-  if (browser) {
-    k = localStorage.getItem("nsec");
-    if (k) {
-      return nip19.decode(k).data as Uint8Array;
-    }
-  }
+	let k;
+	if (browser) {
+		k = localStorage.getItem("nsec");
+		if (k) {
+			return nip19.decode(k).data as Uint8Array;
+		}
+	}
 
-  let { nsec } = user;
+	let { nsec } = user;
 
-  if (nsec) {
-    k = nip49decrypt(nsec, await getPassword());
-  } else k = hexToUint8Array(privateKeyFromSeedWords(await getMnemonic(user)));
+	if (nsec) {
+		k = nip49decrypt(nsec, await getPassword());
+	} else k = hexToUint8Array(privateKeyFromSeedWords(await getMnemonic(user)));
 
-  localStorage.setItem("nsec", nip19.nsecEncode(k));
-  return k;
+	localStorage.setItem("nsec", nip19.nsecEncode(k));
+	return k;
 };
 
 export let getMnemonic = async (user: User) => {
-  let { cipher, salt } = user;
-  let entropy;
+	let { cipher, salt } = user;
+	let entropy;
 
-  entropy = new Uint8Array(
-    await crypto.subtle.decrypt(
-      { name: "AES-GCM", iv: new Uint8Array(16) },
-      await stretch(await getPassword(), 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(await getPassword(), Buffer.from(salt, "hex")),
+			Uint8Array.from(fromWords(decode(cipher, 180).words)),
+		),
+	);
 
-  return entropyToMnemonic(entropy, wordlist);
+	return entropyToMnemonic(entropy, wordlist);
 };
 
 let decodeNsec = (nsec: string): Uint8Array => {
-  let { type, data } = nip19.decode(nsec);
-  if (type === "nsec" && data instanceof Uint8Array) return data;
-  else throw new Error("invalid nsec");
+	let { type, data } = nip19.decode(nsec);
+	if (type === "nsec" && data instanceof Uint8Array) return data;
+	else throw new Error("invalid nsec");
 };
 
 export let getNsec = async (user: User) => {
-  return nip19.nsecEncode(await getPrivateKey(user));
+	return nip19.nsecEncode(await getPrivateKey(user));
 };
 
 export let setNsec = async (user: User, nsec: string) => {
-  user.pubkey = getPublicKey(decodeNsec(nsec));
-  user.nsec = await encryptNsec(nsec);
+	user.pubkey = getPublicKey(decodeNsec(nsec));
+	user.nsec = await encryptNsec(nsec);
 };
 
 export let encryptNsec = async (nsec: string) => {
-  let d = decodeNsec(nsec);
-  return nip49encrypt(d, await getPassword());
+	let d = decodeNsec(nsec);
+	return nip49encrypt(d, await getPassword());
 };
 
 type SignParams = {
-  event: EventTemplate;
-  user: User;
+	event: EventTemplate;
+	user: User;
 };
 
 export let sign = async ({ event, user }: SignParams) => {
-  event = finalizeEvent(event, await getPrivateKey(user));
+	event = finalizeEvent(event, await getPrivateKey(user));
 };
 
 export let send = (event: EventTemplate) => {
-    return post("/events", { event });
+	return post("/events", { event });
 };
 
 let getPassword = async (): Promise<string> => {
-  if (!get(pw)) passwordPrompt.set(true);
-  await wait(() => !!get(pw));
-  return get(pw) || "";
+	if (!get(pw)) passwordPrompt.set(true);
+	await wait(() => !!get(pw));
+	return get(pw) || "";
 };
 
 export let reEncryptEntropy = async (user: User, newPassword: string) => {
-  let { cipher, salt } = user;
+	let { cipher, salt } = user;
 
-  let entropy = await crypto.subtle.decrypt(
-    { name: "AES-GCM", iv: new Uint8Array(16) },
-    await stretch(await getPassword(), hexToUint8Array(salt)),
-    Uint8Array.from(fromWords(decode(cipher, 180).words))
-  );
+	let entropy = await crypto.subtle.decrypt(
+		{ name: "AES-GCM", iv: new Uint8Array(16) },
+		await stretch(await getPassword(), hexToUint8Array(salt)),
+		Uint8Array.from(fromWords(decode(cipher, 180).words)),
+	);
 
-  let bytes = new Uint8Array(
-    await crypto.subtle.encrypt(
-      { name: "AES-GCM", iv: new Uint8Array(16) },
-      await stretch(newPassword, hexToUint8Array(salt)),
-      entropy
-    )
-  );
+	let bytes = new Uint8Array(
+		await crypto.subtle.encrypt(
+			{ name: "AES-GCM", iv: new Uint8Array(16) },
+			await stretch(newPassword, hexToUint8Array(salt)),
+			entropy,
+		),
+	);
 
-  return encode("en", toWords(bytes), 180);
+	return encode("en", toWords(bytes), 180);
 };