diff --git a/api/resolvers/wallet.js b/api/resolvers/wallet.js
index d6f106b7..5621d946 100644
--- a/api/resolvers/wallet.js
+++ b/api/resolvers/wallet.js
@@ -22,7 +22,7 @@ import { lnAddrOptions } from '@/lib/lnurl'
 import { GqlAuthenticationError, GqlAuthorizationError, GqlInputError } from '@/lib/error'
 import { getNodeSockets, getOurPubkey } from '../lnd'
 import validateWallet from '@/wallets/validate'
-import { canReceive } from '@/wallets/common'
+import { canReceive, getWalletByType } from '@/wallets/common'
 import performPaidAction from '../paidAction'
 import performPayingAction from '../payingAction'
 import { timeoutSignal, withTimeout } from '@/lib/time'
@@ -65,6 +65,7 @@ function injectResolvers (resolvers) {
 
       return await upsertWallet({
         wallet,
+        walletDef,
         testCreateInvoice:
           walletDef.testCreateInvoice && validateLightning && canReceive({ def: walletDef, config: data })
             ? (data) => withTimeout(
@@ -558,7 +559,10 @@ const resolvers = {
 
       const logger = walletLogger({ wallet, models })
       await models.wallet.delete({ where: { userId: me.id, id: Number(id) } })
-      logger.info('wallet detached')
+
+      if (canReceive({ def: getWalletByType(wallet.type), config: wallet.wallet })) {
+        logger.info('details for receiving deleted')
+      }
 
       return true
     },
@@ -766,7 +770,7 @@ export const walletLogger = ({ wallet, models }) => {
 }
 
 async function upsertWallet (
-  { wallet, testCreateInvoice }, { settings, data, vaultEntries }, { logger, me, models }) {
+  { wallet, walletDef, testCreateInvoice }, { settings, data, vaultEntries }, { logger, me, models }) {
   if (!me) {
     throw new GqlAuthenticationError()
   }
@@ -872,24 +876,26 @@ async function upsertWallet (
     )
   }
 
-  txs.push(
-    models.walletLog.createMany({
-      data: {
-        userId: me.id,
-        wallet: wallet.type,
-        level: 'SUCCESS',
-        message: id ? 'wallet details updated' : 'wallet attached'
-      }
-    }),
-    models.walletLog.create({
-      data: {
-        userId: me.id,
-        wallet: wallet.type,
-        level: enabled ? 'SUCCESS' : 'INFO',
-        message: enabled ? 'wallet enabled' : 'wallet disabled'
-      }
-    })
-  )
+  if (canReceive({ def: walletDef, config: walletData })) {
+    txs.push(
+      models.walletLog.createMany({
+        data: {
+          userId: me.id,
+          wallet: wallet.type,
+          level: 'SUCCESS',
+          message: id ? 'details for receiving updated' : 'details for receiving saved'
+        }
+      }),
+      models.walletLog.create({
+        data: {
+          userId: me.id,
+          wallet: wallet.type,
+          level: enabled ? 'SUCCESS' : 'INFO',
+          message: enabled ? 'receiving enabled' : 'receiving disabled'
+        }
+      })
+    )
+  }
 
   const [upsertedWallet] = await models.$transaction(txs)
   return upsertedWallet
diff --git a/wallets/config.js b/wallets/config.js
index 4253024f..cdc57424 100644
--- a/wallets/config.js
+++ b/wallets/config.js
@@ -84,33 +84,52 @@ export function useWalletConfigurator (wallet) {
   }, [me?.id, wallet.def.name, reloadLocalWallets])
 
   const save = useCallback(async (newConfig, validateLightning = true) => {
-    const { clientConfig, serverConfig } = await _validate(newConfig, validateLightning)
+    const { clientWithShared: oldClientConfig } = siftConfig(wallet.def.fields, wallet.config)
+    const { clientConfig: newClientConfig, serverConfig: newServerConfig } = await _validate(newConfig, validateLightning)
+
+    const oldCanSend = canSend({ def: wallet.def, config: oldClientConfig })
+    const newCanSend = canSend({ def: wallet.def, config: newClientConfig })
 
     // if vault is active, encrypt and send to server regardless of wallet type
     if (isActive) {
-      await _saveToServer(serverConfig, clientConfig, validateLightning)
+      await _saveToServer(newServerConfig, newClientConfig, validateLightning)
       await _detachFromLocal()
     } else {
-      if (canSend({ def: wallet.def, config: clientConfig })) {
-        await _saveToLocal(clientConfig)
+      if (newCanSend) {
+        await _saveToLocal(newClientConfig)
       } else {
         // if it previously had a client config, remove it
         await _detachFromLocal()
       }
-      if (canReceive({ def: wallet.def, config: serverConfig })) {
-        await _saveToServer(serverConfig, clientConfig, validateLightning)
+      if (canReceive({ def: wallet.def, config: newServerConfig })) {
+        await _saveToServer(newServerConfig, newClientConfig, validateLightning)
       } else if (wallet.config.id) {
         // we previously had a server config
         if (wallet.vaultEntries.length > 0) {
           // we previously had a server config with vault entries, save it
-          await _saveToServer(serverConfig, clientConfig, validateLightning)
+          await _saveToServer(newServerConfig, newClientConfig, validateLightning)
         } else {
           // we previously had a server config without vault entries, remove it
           await _detachFromServer()
         }
       }
     }
-  }, [isActive, wallet.def, _saveToServer, _saveToLocal, _validate,
+
+    if (newCanSend) {
+      if (oldCanSend) {
+        logger.ok('details for sending updated')
+      } else {
+        logger.ok('details for sending saved')
+      }
+      if (newConfig.enabled) {
+        logger.ok('sending enabled')
+      } else {
+        logger.info('sending disabled')
+      }
+    } else if (oldCanSend) {
+      logger.info('details for sending deleted')
+    }
+  }, [isActive, wallet.def, wallet.config, _saveToServer, _saveToLocal, _validate,
     _detachFromLocal, _detachFromServer])
 
   const detach = useCallback(async () => {
@@ -125,7 +144,9 @@ export function useWalletConfigurator (wallet) {
       // if vault is not active and has a client config, delete from local storage
       await _detachFromLocal()
     }
-  }, [isActive, _detachFromServer, _detachFromLocal])
+
+    logger.info('details for sending deleted')
+  }, [logger, isActive, _detachFromServer, _detachFromLocal])
 
   return { save, detach }
 }