Skip wallet tests on priority update (#1327)

* Skip wallet connection tests if only priority is changed

* Fix server priority overrides client priority

* Also add priorityOnly as last argument in generateMutation

api/resolvers/user.js

@@ -628,10 +628,17 @@ export default {
       }
 
       // disable freebies if it hasn't been set yet
-      await models.user.update({
+      try {
-        where: { id: me.id, disableFreebies: null },
+        await models.user.update({
-        data: { disableFreebies: true }
+          where: { id: me.id, disableFreebies: null },
-      })
+          data: { disableFreebies: true }
+        })
+      } catch (err) {
+        // ignore 'record not found' errors
+        if (err.code !== 'P2025') {
+          throw err
+        }
+      }
 
       return true
     },

api/resolvers/wallet.js

@@ -22,18 +22,20 @@ function injectResolvers (resolvers) {
     const resolverName = generateResolverName(w.walletField)
     console.log(resolverName)
 
-    resolvers.Mutation[resolverName] = async (parent, { settings, ...data }, { me, models }) => {
+    resolvers.Mutation[resolverName] = async (parent, { settings, priorityOnly, ...data }, { me, models }) => {
       // allow transformation of the data on validation (this is optional ... won't do anything if not implemented)
-      const validData = await walletValidate(w, { ...data, ...settings })
+      if (!priorityOnly) {
-      if (validData) {
+        const validData = await walletValidate(w, { ...data, ...settings })
-        Object.keys(validData).filter(key => key in data).forEach(key => { data[key] = validData[key] })
+        if (validData) {
-        Object.keys(validData).filter(key => key in settings).forEach(key => { settings[key] = validData[key] })
+          Object.keys(validData).filter(key => key in data).forEach(key => { data[key] = validData[key] })
+          Object.keys(validData).filter(key => key in settings).forEach(key => { settings[key] = validData[key] })
+        }
       }
 
       return await upsertWallet({
         wallet: { field: w.walletField, type: w.walletType },
         testCreateInvoice: (data) => w.testCreateInvoice(data, { me, models })
-      }, { settings, data }, { me, models })
+      }, { settings, data, priorityOnly }, { me, models })
     }
   }
   console.groupEnd()
@@ -571,13 +573,13 @@ export const addWalletLog = async ({ wallet, level, message }, { models }) => {
 }
 
 async function upsertWallet (
-  { wallet, testCreateInvoice }, { settings, data }, { me, models }) {
+  { wallet, testCreateInvoice }, { settings, data, priorityOnly }, { me, models }) {
   if (!me) {
     throw new GraphQLError('you must be logged in', { extensions: { code: 'UNAUTHENTICATED' } })
   }
   assertApiKeyNotPermitted({ me })
 
-  if (testCreateInvoice) {
+  if (testCreateInvoice && !priorityOnly) {
     try {
       await testCreateInvoice(data)
     } catch (err) {

api/typeDefs/wallet.js

@@ -17,7 +17,7 @@ function mutationTypeDefs () {
     args += w.fields
       .filter(isServerField)
       .map(fieldToGqlArg).join(', ')
-    args += ', settings: AutowithdrawSettings!'
+    args += ', settings: AutowithdrawSettings!, priorityOnly: Boolean'
     const resolverName = generateResolverName(w.walletField)
     const typeDef = `${resolverName}(${args}): Boolean`
     console.log(typeDef)

wallets/index.js

@@ -71,7 +71,7 @@ export function useWallet (name) {
   const setPriority = useCallback(async (priority) => {
     if (_isConfigured && priority !== config.priority) {
       try {
-        await saveConfig({ ...config, priority }, { logger })
+        await saveConfig({ ...config, priority }, { logger, priorityOnly: true })
       } catch (err) {
         toaster.danger(`failed to change priority of ${wallet.name} wallet: ${err.message}`)
       }
@@ -161,16 +161,19 @@ function useConfig (wallet) {
   let config = {}
   if (hasClientConfig) config = clientConfig
   if (hasServerConfig) {
-    const { enabled } = config || {}
+    const { enabled, priority } = config || {}
     config = {
       ...config,
       ...serverConfig
     }
     // wallet is enabled if enabled is set in client or server config
     config.enabled ||= enabled
+    // priority might only be set on client or server
+    // ie. if send+recv is available but only one is configured
+    config.priority ||= priority
   }
 
-  const saveConfig = useCallback(async (newConfig, { logger }) => {
+  const saveConfig = useCallback(async (newConfig, { logger, priorityOnly }) => {
     // NOTE:
     //   verifying the client/server configuration before saving it
     //   prevents unsetting just one configuration if both are set.
@@ -189,23 +192,28 @@ function useConfig (wallet) {
       }
 
       if (valid) {
-        try {
+        if (priorityOnly) {
+          setClientConfig(newConfig)
+        } else {
+          try {
           // XXX: testSendPayment can return a new config (e.g. lnc)
-          const newerConfig = await wallet.testSendPayment?.(newConfig, { me, logger })
+            const newerConfig = await wallet.testSendPayment?.(newConfig, { me, logger })
-          if (newerConfig) {
+            if (newerConfig) {
-            newClientConfig = newerConfig
+              newClientConfig = newerConfig
+            }
+          } catch (err) {
+            logger.error(err.message)
+            throw err
           }
-        } catch (err) {
-          logger.error(err.message)
-          throw err
-        }
 
-        setClientConfig(newClientConfig)
+          setClientConfig(newClientConfig)
-        logger.ok(wallet.isConfigured ? 'payment details updated' : 'wallet attached for payments')
+          logger.ok(wallet.isConfigured ? 'payment details updated' : 'wallet attached for payments')
-        if (newConfig.enabled) wallet.enablePayments()
+          if (newConfig.enabled) wallet.enablePayments()
-        else wallet.disablePayments()
+          else wallet.disablePayments()
+        }
       }
     }
+
     if (hasServerConfig) {
       let newServerConfig = extractServerConfig(wallet.fields, newConfig)
 
@@ -216,7 +224,7 @@ function useConfig (wallet) {
         valid = false
       }
 
-      if (valid) await setServerConfig(newServerConfig)
+      if (valid) await setServerConfig(newServerConfig, { priorityOnly })
     }
   }, [hasClientConfig, hasServerConfig, setClientConfig, setServerConfig, wallet])
 
@@ -273,7 +281,7 @@ function useServerConfig (wallet) {
     priority,
     enabled,
     ...config
-  }) => {
+  }, { priorityOnly }) => {
     try {
       const mutation = generateMutation(wallet)
       return await client.mutate({
@@ -286,7 +294,8 @@ function useServerConfig (wallet) {
             autoWithdrawMaxFeePercent: Number(autoWithdrawMaxFeePercent),
             priority,
             enabled
-          }
+          },
+          priorityOnly
         }
       })
     } finally {
@@ -326,13 +335,13 @@ function generateMutation (wallet) {
       }
       return arg
     }).join(', ')
-  headerArgs += ', $settings: AutowithdrawSettings!'
+  headerArgs += ', $settings: AutowithdrawSettings!, $priorityOnly: Boolean'
 
   let inputArgs = 'id: $id, '
   inputArgs += wallet.fields
     .filter(isServerField)
     .map(f => `${f.name}: $${f.name}`).join(', ')
-  inputArgs += ', settings: $settings'
+  inputArgs += ', settings: $settings, priorityOnly: $priorityOnly'
 
   return gql`mutation ${resolverName}(${headerArgs}) {
     ${resolverName}(${inputArgs})