Pass config with spread operator

* wrong storage key was used
* broke if wallets with no configs existed

components/wallet/index.js

@@ -7,7 +7,8 @@ import { bolt11Tags } from '@/lib/bolt11'
 
 // wallet definitions
 export const WALLET_DEFS = [
-  await import('@/components/wallet/lnbits')
+  await import('@/components/wallet/lnbits'),
+  await import('@/components/wallet/nwc')
 ]
 
 export const Status = {
@@ -29,7 +30,7 @@ export function useWallet (name) {
     const hash = bolt11Tags(bolt11).payment_hash
     logger.info('sending payment:', `payment_hash=${hash}`)
     try {
-      const { preimage } = await wallet.sendPayment({ bolt11, config })
+      const { preimage } = await wallet.sendPayment({ bolt11, ...config, logger })
       logger.ok('payment successful:', `payment_hash=${hash}`, `preimage=${preimage}`)
     } catch (err) {
       const message = err.message || err.toString?.()
@@ -38,17 +39,6 @@ export function useWallet (name) {
     }
   }, [wallet, config, logger])
 
-  const validate = useCallback(async (values) => {
-    try {
-      // validate should log custom INFO and OK message
-      return await wallet.validate({ logger, ...values })
-    } catch (err) {
-      const message = err.message || err.toString?.()
-      logger.error(message)
-      throw err
-    }
-  }, [wallet, logger])
-
   const enable = useCallback(() => {
     enableWallet(name, me)
     logger.ok('wallet enabled')
@@ -56,15 +46,18 @@ export function useWallet (name) {
 
   const disable = useCallback(() => {
     disableWallet(name, me)
-    logger.ok('wallet disabled')
+    logger.info('wallet disabled')
   }, [name, me, logger])
 
-  const save = useCallback((values) => {
+  const save = useCallback(async (config) => {
     try {
-      saveConfig(values)
+      // validate should log custom INFO and OK message
+      // TODO: add timeout
+      await wallet.validate({ logger, ...config })
+      saveConfig(config)
       logger.ok('wallet attached')
     } catch (err) {
-      const message = 'failed to attach: ' + err.message || err.toString?.()
+      const message = err.message || err.toString?.()
       logger.error(message)
       throw err
     }
@@ -76,7 +69,7 @@ export function useWallet (name) {
       clearConfig()
       logger.ok('wallet detached')
     } catch (err) {
-      const message = 'failed to detach: ' + err.message || err.toString?.()
+      const message = err.message || err.toString?.()
       logger.error(message)
       throw err
     }
@@ -85,7 +78,6 @@ export function useWallet (name) {
   return {
     ...wallet,
     sendPayment,
-    validate,
     config,
     save,
     delete: delete_,
@@ -125,11 +117,11 @@ function getStorageKey (name, me) {
 function enableWallet (name, me) {
   // mark all wallets as disabled except the one to enable
   for (const walletDef of WALLET_DEFS) {
+    const key = getStorageKey(walletDef.name, me)
+    let config = JSON.parse(window.localStorage.getItem(key))
     const toEnable = walletDef.name === name
-    const key = getStorageKey(name, me)
-    const config = JSON.parse(window.localStorage.getItem(key))
-    if (config.enabled || toEnable) {
-      config.enabled = toEnable
+    if (config || toEnable) {
+      config = { ...config, enabled: toEnable }
       window.localStorage.setItem(key, JSON.stringify(config))
     }
   }

components/wallet/lnbits.js

@@ -18,11 +18,14 @@ export const fields = [
 
 export const card = {
   title: 'LNbits',
+  subtitle: 'use LNbits for payments',
   badges: ['send only', 'non-custodialish']
 }
 
-export async function validate ({ logger, ...config }) {
-  return await getInfo({ logger, ...config })
+export async function validate ({ logger, url, adminKey }) {
+  logger.info('trying to fetch wallet')
+  await getWallet(url, adminKey)
+  logger.ok('wallet found')
 }
 
 export const schema = object({
@@ -50,28 +53,7 @@ export const schema = object({
   adminKey: string().length(32)
 })
 
-async function getInfo ({ logger, ...config }) {
-  logger.info('trying to fetch wallet')
-  const response = await getWallet(config.url, config.adminKey)
-  logger.ok('wallet found')
-  return {
-    node: {
-      alias: response.name,
-      pubkey: ''
-    },
-    methods: [
-      'getInfo',
-      'getBalance',
-      'sendPayment'
-    ],
-    version: '1.0',
-    supports: ['lightning']
-  }
-}
-
-export async function sendPayment ({ bolt11, config }) {
-  const { url, adminKey } = config
-
+export async function sendPayment ({ bolt11, url, adminKey }) {
   const response = await postPayment(url, adminKey, bolt11)
 
   const checkResponse = await getPayment(url, adminKey, response.payment_hash)

components/wallet/nwc.js

@@ -0,0 +1,161 @@
+import { NOSTR_PUBKEY_HEX } from '@/lib/nostr'
+import { parseNwcUrl } from '@/lib/url'
+import { Relay, finalizeEvent, nip04 } from 'nostr-tools'
+import { object, string } from 'yup'
+
+export const name = 'nwc'
+
+export const fields = [
+  {
+    name: 'nwcUrl',
+    label: 'connection',
+    type: 'password'
+  }
+]
+
+export const card = {
+  title: 'NWC',
+  subtitle: 'use Nostr Wallet Connect for payments',
+  badges: ['send only', 'non-custodialish']
+}
+
+export const schema = object({
+  nwcUrl: string()
+    .required('required')
+    .test(async (nwcUrl, context) => {
+      // run validation in sequence to control order of errors
+      // inspired by https://github.com/jquense/yup/issues/851#issuecomment-1049705180
+      try {
+        await string().required('required').validate(nwcUrl)
+        await string().matches(/^nostr\+?walletconnect:\/\//, { message: 'must start with nostr+walletconnect://' }).validate(nwcUrl)
+        let relayUrl, walletPubkey, secret
+        try {
+          ({ relayUrl, walletPubkey, secret } = parseNwcUrl(nwcUrl))
+        } catch {
+          // invalid URL error. handle as if pubkey validation failed to not confuse user.
+          throw new Error('pubkey must be 64 hex chars')
+        }
+        await string().required('pubkey required').trim().matches(NOSTR_PUBKEY_HEX, 'pubkey must be 64 hex chars').validate(walletPubkey)
+        await string().required('relay url required').trim().wss('relay must use wss://').validate(relayUrl)
+        await string().required('secret required').trim().matches(/^[0-9a-fA-F]{64}$/, 'secret must be 64 hex chars').validate(secret)
+      } catch (err) {
+        return context.createError({ message: err.message })
+      }
+      return true
+    })
+})
+
+export async function validate ({ logger, nwcUrl }) {
+  const { relayUrl, walletPubkey } = parseNwcUrl(nwcUrl)
+
+  logger.info(`requesting info event from ${relayUrl}`)
+  const relay = await Relay
+    .connect(relayUrl)
+    .catch(() => {
+      // NOTE: passed error is undefined for some reason
+      const msg = `failed to connect to ${relayUrl}`
+      logger.error(msg)
+      throw new Error(msg)
+    })
+  logger.ok(`connected to ${relayUrl}`)
+
+  try {
+    return await new Promise((resolve, reject) => {
+      let found = false
+      const sub = relay.subscribe([
+        {
+          kinds: [13194],
+          authors: [walletPubkey]
+        }
+      ], {
+        onevent (event) {
+          found = true
+          logger.ok(`received info event from ${relayUrl}`)
+          resolve(event)
+        },
+        onclose (reason) {
+          if (!['closed by caller', 'relay connection closed by us'].includes(reason)) {
+            // only log if not closed by us (caller)
+            const msg = 'connection closed: ' + (reason || 'unknown reason')
+            logger.error(msg)
+            reject(new Error(msg))
+          }
+        },
+        oneose () {
+          if (!found) {
+            const msg = 'EOSE received without info event'
+            logger.error(msg)
+            reject(new Error(msg))
+          }
+          sub?.close()
+        }
+      })
+    })
+  } finally {
+    // For some reason, websocket is already in CLOSING or CLOSED state.
+    // relay?.close()
+    if (relay) logger.info(`closed connection to ${relayUrl}`)
+  }
+}
+
+export async function sendPayment ({ bolt11, nwcUrl, logger }) {
+  const { relayUrl, walletPubkey, secret } = parseNwcUrl(nwcUrl)
+
+  const relay = await Relay.connect(relayUrl).catch(() => {
+    // NOTE: passed error is undefined for some reason
+    const msg = `failed to connect to ${relayUrl}`
+    logger.error(msg)
+    throw new Error(msg)
+  })
+  logger.ok(`connected to ${relayUrl}`)
+
+  try {
+    const ret = await new Promise(function (resolve, reject) {
+      (async function () {
+        const payload = {
+          method: 'pay_invoice',
+          params: { invoice: bolt11 }
+        }
+        const content = await nip04.encrypt(secret, walletPubkey, JSON.stringify(payload))
+
+        const request = finalizeEvent({
+          kind: 23194,
+          created_at: Math.floor(Date.now() / 1000),
+          tags: [['p', walletPubkey]],
+          content
+        }, secret)
+        await relay.publish(request)
+
+        const filter = {
+          kinds: [23195],
+          authors: [walletPubkey],
+          '#e': [request.id]
+        }
+        relay.subscribe([filter], {
+          async onevent (response) {
+            try {
+              const content = JSON.parse(await nip04.decrypt(secret, walletPubkey, response.content))
+              if (content.error) return reject(new Error(content.error.message))
+              if (content.result) return resolve({ preimage: content.result.preimage })
+            } catch (err) {
+              return reject(err)
+            }
+          },
+          onclose (reason) {
+            if (!['closed by caller', 'relay connection closed by us'].includes(reason)) {
+              // only log if not closed by us (caller)
+              const msg = 'connection closed: ' + (reason || 'unknown reason')
+              logger.error(msg)
+              reject(new Error(msg))
+            }
+          }
+        })
+      })().catch(reject)
+    })
+    return ret
+  } finally {
+    // For some reason, websocket is already in CLOSING or CLOSED state.
+    // relay?.close()
+    if (relay) logger.info(`closed connection to ${relayUrl}`)
+  }
+}

lib/validate.js

@@ -10,7 +10,6 @@ import { msatsToSats, numWithUnits, abbrNum, ensureB64, B64_URL_REGEX } from './
 import * as usersFragments from '@/fragments/users'
 import * as subsFragments from '@/fragments/subs'
 import { isInvoicableMacaroon, isInvoiceMacaroon } from './macaroon'
-import { parseNwcUrl } from './url'
 import { datePivot } from './time'
 import { decodeRune } from '@/lib/cln'
 import bip39Words from './bip39-words'
@@ -600,32 +599,6 @@ export const lnAddrSchema = ({ payerData, min, max, commentAllowed } = {}) =>
     return accum
   }, {})))
 
-export const nwcSchema = object({
-  nwcUrl: string()
-    .required('required')
-    .test(async (nwcUrl, context) => {
-      // run validation in sequence to control order of errors
-      // inspired by https://github.com/jquense/yup/issues/851#issuecomment-1049705180
-      try {
-        await string().required('required').validate(nwcUrl)
-        await string().matches(/^nostr\+?walletconnect:\/\//, { message: 'must start with nostr+walletconnect://' }).validate(nwcUrl)
-        let relayUrl, walletPubkey, secret
-        try {
-          ({ relayUrl, walletPubkey, secret } = parseNwcUrl(nwcUrl))
-        } catch {
-          // invalid URL error. handle as if pubkey validation failed to not confuse user.
-          throw new Error('pubkey must be 64 hex chars')
-        }
-        await string().required('pubkey required').trim().matches(NOSTR_PUBKEY_HEX, 'pubkey must be 64 hex chars').validate(walletPubkey)
-        await string().required('relay url required').trim().wss('relay must use wss://').validate(relayUrl)
-        await string().required('secret required').trim().matches(/^[0-9a-fA-F]{64}$/, 'secret must be 64 hex chars').validate(secret)
-      } catch (err) {
-        return context.createError({ message: err.message })
-      }
-      return true
-    })
-})
-
 export const lncSchema = object({
   pairingPhrase: array()
     .transform(function (value, originalValue) {

pages/settings/wallets/[wallet].js

@@ -21,14 +21,12 @@ export default function WalletSettings () {
       ...acc,
       [field.name]: wallet.config?.[field.name] || ''
     }
-  }, {
-    isDefault: wallet.isDefault || false
-  })
+  }, {})
 
   return (
     <CenterLayout>
       <h2 className='pb-2'>{wallet.card.title}</h2>
-      <h6 className='text-muted text-center pb-3'>use {wallet.card.title} for payments</h6>
+      <h6 className='text-muted text-center pb-3'>{wallet.card.subtitle}</h6>
       <WalletSecurityBanner />
       <Form
         initial={initial}
@@ -36,8 +34,7 @@ export default function WalletSettings () {
         onSubmit={async ({ enabled, ...values }) => {
           try {
             const newConfig = !wallet.isConfigured
-            await wallet.validate(values)
-            wallet.save(values)
+            await wallet.save(values)
             // enable wallet if checkbox was set or if wallet was just configured
             if (enabled || newConfig) wallet.enable()
             else wallet.disable()