chore: format and lint

extension/background.js

@@ -1,13 +1,16 @@
 import browser from 'webextension-polyfill'
 import {
   validateEvent,
-  getSignature,
+  finalizeEvent,
   getEventHash,
   getPublicKey,
-  nip19
+  nip19,
+  utils
 } from 'nostr-tools'
-import {nip04} from 'nostr-tools'
-import {Mutex} from 'async-mutex'
+import { nip04 } from 'nostr-tools'
+
+const { hexToBytes } = utils
+import { Mutex } from 'async-mutex'
 
 import {
   NO_PERMISSIONS_REQUIRED,
@@ -16,10 +19,10 @@ import {
   showNotification
 } from './common'
 
-const {encrypt, decrypt} = nip04
+const { encrypt, decrypt } = nip04
 
 let openPrompt = null
-let promptMutex = new Mutex()
+const promptMutex = new Mutex()
 let releasePromptMutex = () => {}
 
 browser.runtime.onInstalled.addListener((_, __, reason) => {
@@ -27,7 +30,7 @@ browser.runtime.onInstalled.addListener((_, __, reason) => {
 })
 
 browser.runtime.onMessage.addListener(async (req, sender) => {
-  let {prompt} = req
+  const { prompt } = req
 
   if (prompt) {
     handlePromptMessage(req, sender)
@@ -37,46 +40,46 @@ browser.runtime.onMessage.addListener(async (req, sender) => {
 })
 
 browser.runtime.onMessageExternal.addListener(
-  async ({type, params}, sender) => {
-    let extensionId = new URL(sender.url).host
-    return handleContentScriptMessage({type, params, host: extensionId})
+  async ({ type, params }, sender) => {
+    const extensionId = new URL(sender.url).host
+    return handleContentScriptMessage({ type, params, host: extensionId })
   }
 )
 
-browser.windows.onRemoved.addListener(windowId => {
+browser.windows.onRemoved.addListener((_windowId) => {
   if (openPrompt) {
     // calling this with a simple "no" response will not store anything, so it's fine
     // it will just return a failure
-    handlePromptMessage({accept: false}, null)
+    handlePromptMessage({ accept: false }, null)
   }
 })
 
-async function handleContentScriptMessage({type, params, host}) {
+async function handleContentScriptMessage({ type, params, host }) {
   if (NO_PERMISSIONS_REQUIRED[type]) {
     // authorized, and we won't do anything with private key here, so do a separate handler
     switch (type) {
       case 'replaceURL': {
-        let {protocol_handler: ph} = await browser.storage.local.get([
+        const { protocol_handler: ph } = await browser.storage.local.get([
           'protocol_handler'
         ])
         if (!ph) return false
 
-        let {url} = params
-        let raw = url.split('nostr:')[1]
-        let {type, data} = nip19.decode(raw)
-        let replacements = {
+        const { url } = params
+        const raw = url.split('nostr:')[1]
+        const { type, data } = nip19.decode(raw)
+        const replacements = {
           raw,
           hrp: type,
           hex:
             type === 'npub' || type === 'note'
               ? data
               : type === 'nprofile'
-              ? data.pubkey
-              : type === 'nevent'
-              ? data.id
-              : null,
-          p_or_e: {npub: 'p', note: 'e', nprofile: 'p', nevent: 'e'}[type],
-          u_or_n: {npub: 'u', note: 'n', nprofile: 'u', nevent: 'n'}[type],
+                ? data.pubkey
+                : type === 'nevent'
+                  ? data.id
+                  : null,
+          p_or_e: { npub: 'p', note: 'e', nprofile: 'p', nevent: 'e' }[type],
+          u_or_n: { npub: 'u', note: 'n', nprofile: 'u', nevent: 'n' }[type],
           relay0: type === 'nprofile' ? data.relays[0] : null,
           relay1: type === 'nprofile' ? data.relays[1] : null,
           relay2: type === 'nprofile' ? data.relays[2] : null
@@ -95,7 +98,7 @@ async function handleContentScriptMessage({type, params, host}) {
     // acquire mutex here before reading policies
     releasePromptMutex = await promptMutex.acquire()
 
-    let allowed = await getPermissionStatus(
+    const allowed = await getPermissionStatus(
       host,
       type,
       type === 'signEvent' ? params.event : undefined
@@ -115,8 +118,8 @@ async function handleContentScriptMessage({type, params, host}) {
     } else {
       // ask for authorization
       try {
-        let id = Math.random().toString().slice(4)
-        let qs = new URLSearchParams({
+        const id = Math.random().toString().slice(4)
+        const qs = new URLSearchParams({
           host,
           id,
           params: JSON.stringify(params),
@@ -124,8 +127,8 @@ async function handleContentScriptMessage({type, params, host}) {
         })
 
         // prompt will be resolved with true or false
-        let accept = await new Promise((resolve, reject) => {
-          openPrompt = {resolve, reject}
+        const accept = await new Promise((resolve, reject) => {
+          openPrompt = { resolve, reject }
           const url = `${browser.runtime.getURL(
             'prompt.html'
           )}?${qs.toString()}`
@@ -146,7 +149,7 @@ async function handleContentScriptMessage({type, params, host}) {
         })
 
         // denied, stop here
-        if (!accept) return {error: 'denied'}
+        if (!accept) return { error: 'denied' }
       } catch (err) {
         // errored, stop here
         releasePromptMutex()
@@ -158,47 +161,48 @@ async function handleContentScriptMessage({type, params, host}) {
   }
 
   // if we're here this means it was accepted
-  let results = await browser.storage.local.get('private_key')
-  if (!results || !results.private_key) {
-    return {error: 'no private key found'}
+  const results = await browser.storage.local.get('private_key')
+  if (!results?.private_key) {
+    return { error: 'no private key found' }
   }
 
-  let sk = results.private_key
+  const sk = results.private_key
 
   try {
     switch (type) {
       case 'getPublicKey': {
-        return getPublicKey(sk)
+        return getPublicKey(hexToBytes(sk))
       }
       case 'getRelays': {
-        let results = await browser.storage.local.get('relays')
+        const results = await browser.storage.local.get('relays')
         return results.relays || {}
       }
       case 'signEvent': {
-        let {event} = params
+        const { event } = params
 
-        if (!event.pubkey) event.pubkey = getPublicKey(sk)
+        if (!event.pubkey) event.pubkey = getPublicKey(hexToBytes(sk))
         if (!event.id) event.id = getEventHash(event)
-        if (!validateEvent(event)) return {error: {message: 'invalid event'}}
+        if (!validateEvent(event))
+          return { error: { message: 'invalid event' } }
 
-        event.sig = await getSignature(event, sk)
-        return event
+        const signedEvent = finalizeEvent(event, hexToBytes(sk))
+        return signedEvent
       }
       case 'nip04.encrypt': {
-        let {peer, plaintext} = params
+        const { peer, plaintext } = params
         return encrypt(sk, peer, plaintext)
       }
       case 'nip04.decrypt': {
-        let {peer, ciphertext} = params
+        const { peer, ciphertext } = params
         return decrypt(sk, peer, ciphertext)
       }
     }
   } catch (error) {
-    return {error: {message: error.message, stack: error.stack}}
+    return { error: { message: error.message, stack: error.stack } }
   }
 }
 
-async function handlePromptMessage({host, type, accept, conditions}, sender) {
+async function handlePromptMessage({ host, type, accept, conditions }, sender) {
   // return response
   openPrompt?.resolve?.(accept)