diff --git a/.mockery.yaml b/.mockery.yaml
new file mode 100644
index 000000000..f904dd452
--- /dev/null
+++ b/.mockery.yaml
@@ -0,0 +1,16 @@
+filename: "{{.InterfaceName}}.go"
+dir: tests/mocks
+outpkg: mocks
+
+# Fix deprecation warnings:
+issue-845-fix: True
+resolve-type-alias: False
+
+packages:
+  github.com/getAlby/hub/service:
+    interfaces:
+      Service:
+
+  github.com/getAlby/hub/lnclient:
+    interfaces:
+      LNClient:
diff --git a/README.md b/README.md
index a1af8712d..383637759 100644
--- a/README.md
+++ b/README.md
@@ -95,6 +95,14 @@ _If you get a blank screen, try running in your normal terminal (outside of vsco
 
     $ go test ./... -run TestHandleGetInfoEvent
 
+#### Mocking
+
+We use [testify/mock](https://github.com/stretchr/testify) to facilitate mocking in tests. Instead of writing mocks manually, we generate them using [vektra/mockery](https://github.com/vektra/mockery). To regenerate them, [install mockery](https://vektra.github.io/mockery/latest/installation) and run it in the project's root directory:
+
+    $ mockery
+
+Mockery loads its configuration from the .mockery.yaml file in the root directory of this project. To add mocks for new interfaces, add them to the configuration file and run mockery.
+
 ### Profiling
 
 The application supports both the Go pprof library and the DataDog profiler.
diff --git a/api/api.go b/api/api.go
index c81d0cb93..2ef4b30fd 100644
--- a/api/api.go
+++ b/api/api.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"flag"
 	"fmt"
 	"io"
 	"net/http"
@@ -1068,6 +1069,93 @@ func (api *api) Health(ctx context.Context) (*HealthResponse, error) {
 	return &HealthResponse{Alarms: alarms}, nil
 }
 
+func (api *api) GetCustomNodeCommands() (*CustomNodeCommandsResponse, error) {
+	lnClient := api.svc.GetLNClient()
+	if lnClient == nil {
+		return nil, errors.New("LNClient not started")
+	}
+
+	allCommandDefs := lnClient.GetCustomNodeCommandDefinitions()
+	commandDefs := make([]CustomNodeCommandDef, 0, len(allCommandDefs))
+	for _, commandDef := range allCommandDefs {
+		argDefs := make([]CustomNodeCommandArgDef, 0, len(commandDef.Args))
+		for _, argDef := range commandDef.Args {
+			argDefs = append(argDefs, CustomNodeCommandArgDef{
+				Name:        argDef.Name,
+				Description: argDef.Description,
+			})
+		}
+		commandDefs = append(commandDefs, CustomNodeCommandDef{
+			Name:        commandDef.Name,
+			Description: commandDef.Description,
+			Args:        argDefs,
+		})
+	}
+
+	return &CustomNodeCommandsResponse{Commands: commandDefs}, nil
+}
+
+func (api *api) ExecuteCustomNodeCommand(ctx context.Context, command string) (interface{}, error) {
+	lnClient := api.svc.GetLNClient()
+	if lnClient == nil {
+		return nil, errors.New("LNClient not started")
+	}
+
+	// Split command line into arguments. Command name must be the first argument.
+	parsedArgs, err := utils.ParseCommandLine(command)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse node command: %w", err)
+	} else if len(parsedArgs) == 0 {
+		return nil, errors.New("no command provided")
+	}
+
+	// Look up the requested command definition.
+	allCommandDefs := lnClient.GetCustomNodeCommandDefinitions()
+	commandDefIdx := slices.IndexFunc(allCommandDefs, func(def lnclient.CustomNodeCommandDef) bool {
+		return def.Name == parsedArgs[0]
+	})
+	if commandDefIdx < 0 {
+		return nil, fmt.Errorf("unknown command: %q", parsedArgs[0])
+	}
+
+	// Build flag set.
+	commandDef := allCommandDefs[commandDefIdx]
+	flagSet := flag.NewFlagSet(commandDef.Name, flag.ContinueOnError)
+	for _, argDef := range commandDef.Args {
+		flagSet.String(argDef.Name, "", argDef.Description)
+	}
+
+	if err = flagSet.Parse(parsedArgs[1:]); err != nil {
+		return nil, fmt.Errorf("failed to parse command arguments: %w", err)
+	}
+
+	// Collect flags that have been set.
+	argValues := make(map[string]string)
+	flagSet.Visit(func(f *flag.Flag) {
+		argValues[f.Name] = f.Value.String()
+	})
+
+	reqArgs := make([]lnclient.CustomNodeCommandArg, 0, len(argValues))
+	for _, argDef := range commandDef.Args {
+		if argValue, ok := argValues[argDef.Name]; ok {
+			reqArgs = append(reqArgs, lnclient.CustomNodeCommandArg{
+				Name:  argDef.Name,
+				Value: argValue,
+			})
+		}
+	}
+
+	nodeResp, err := lnClient.ExecuteCustomNodeCommand(ctx, &lnclient.CustomNodeCommandRequest{
+		Name: commandDef.Name,
+		Args: reqArgs,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("node failed to execute custom command: %w", err)
+	}
+
+	return nodeResp.Response, nil
+}
+
 func (api *api) parseExpiresAt(expiresAtString string) (*time.Time, error) {
 	var expiresAt *time.Time
 	if expiresAtString != "" {
diff --git a/api/api_test.go b/api/api_test.go
new file mode 100644
index 000000000..0b876706e
--- /dev/null
+++ b/api/api_test.go
@@ -0,0 +1,228 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	"github.com/getAlby/hub/lnclient"
+	"github.com/getAlby/hub/service"
+	"github.com/getAlby/hub/tests/mocks"
+)
+
+func TestGetCustomNodeCommandDefinitions(t *testing.T) {
+	lnClient := mocks.NewMockLNClient(t)
+	svc := mocks.NewMockService(t)
+
+	mockLNCommandDefs := []lnclient.CustomNodeCommandDef{
+		{
+			Name:        "no_args",
+			Description: "command without args",
+			Args:        nil,
+		},
+		{
+			Name:        "with_args",
+			Description: "command with args",
+			Args: []lnclient.CustomNodeCommandArgDef{
+				{Name: "arg1", Description: "first argument"},
+				{Name: "arg2", Description: "second argument"},
+			},
+		},
+	}
+
+	expectedCommands := []CustomNodeCommandDef{
+		{
+			Name:        "no_args",
+			Description: "command without args",
+			Args:        []CustomNodeCommandArgDef{},
+		},
+		{
+			Name:        "with_args",
+			Description: "command with args",
+			Args: []CustomNodeCommandArgDef{
+				{Name: "arg1", Description: "first argument"},
+				{Name: "arg2", Description: "second argument"},
+			},
+		},
+	}
+
+	lnClient.On("GetCustomNodeCommandDefinitions").Return(mockLNCommandDefs)
+	svc.On("GetLNClient").Return(lnClient)
+
+	theAPI := instantiateAPIWithService(svc)
+
+	commands, err := theAPI.GetCustomNodeCommands()
+	require.NoError(t, err)
+	require.NotNil(t, commands)
+	require.ElementsMatch(t, expectedCommands, commands.Commands)
+}
+
+func TestExecuteCustomNodeCommand(t *testing.T) {
+	type testCase struct {
+		name                 string
+		apiCommandLine       string
+		lnSupportedCommands  []lnclient.CustomNodeCommandDef
+		lnExpectedCommandReq *lnclient.CustomNodeCommandRequest
+		lnResponse           *lnclient.CustomNodeCommandResponse
+		lnError              error
+		apiExpectedResponse  interface{}
+		apiExpectedErr       string
+	}
+
+	// Successful execution of a command without args.
+	testCaseOkNoArgs := testCase{
+		name:                 "command without args",
+		apiCommandLine:       "test_command",
+		lnSupportedCommands:  []lnclient.CustomNodeCommandDef{{Name: "test_command"}},
+		lnExpectedCommandReq: &lnclient.CustomNodeCommandRequest{Name: "test_command", Args: []lnclient.CustomNodeCommandArg{}},
+		lnResponse:           &lnclient.CustomNodeCommandResponse{Response: "ok"},
+		lnError:              nil,
+		apiExpectedResponse:  "ok",
+		apiExpectedErr:       "",
+	}
+
+	// Successful execution of a command with args. The command line contains
+	// different arg value styles: with '=' and with space.
+	testCaseOkWithArgs := testCase{
+		name:           "command with args",
+		apiCommandLine: "test_command --arg1=foo --arg2 bar",
+		lnSupportedCommands: []lnclient.CustomNodeCommandDef{
+			{
+				Name: "test_command",
+				Args: []lnclient.CustomNodeCommandArgDef{
+					{Name: "arg1", Description: "argument one"},
+					{Name: "arg2", Description: "argument two"},
+				},
+			},
+		},
+		lnExpectedCommandReq: &lnclient.CustomNodeCommandRequest{Name: "test_command", Args: []lnclient.CustomNodeCommandArg{
+			{Name: "arg1", Value: "foo"},
+			{Name: "arg2", Value: "bar"},
+		}},
+		lnResponse:          &lnclient.CustomNodeCommandResponse{Response: "ok"},
+		lnError:             nil,
+		apiExpectedResponse: "ok",
+		apiExpectedErr:      "",
+	}
+
+	// Successful execution of a command with a possible but unset arg.
+	testCaseOkWithUnsetArg := testCase{
+		name:           "command with unset arg",
+		apiCommandLine: "test_command",
+		lnSupportedCommands: []lnclient.CustomNodeCommandDef{
+			{Name: "test_command", Args: []lnclient.CustomNodeCommandArgDef{{Name: "arg1", Description: "argument one"}}},
+		},
+		lnExpectedCommandReq: &lnclient.CustomNodeCommandRequest{Name: "test_command", Args: []lnclient.CustomNodeCommandArg{}},
+		lnResponse:           &lnclient.CustomNodeCommandResponse{Response: "ok"},
+		lnError:              nil,
+		apiExpectedResponse:  "ok",
+		apiExpectedErr:       "",
+	}
+
+	// Error: command line is empty.
+	testCaseErrEmptyCommand := testCase{
+		name:                 "empty command",
+		apiCommandLine:       "",
+		lnSupportedCommands:  nil,
+		lnExpectedCommandReq: nil,
+		lnResponse:           nil,
+		lnError:              nil,
+		apiExpectedResponse:  nil,
+		apiExpectedErr:       "no command provided",
+	}
+
+	// Error: command line is malformed, i.e. non-parseable.
+	testCaseErrMalformedCommand := testCase{
+		name:                 "command with unclosed quote",
+		apiCommandLine:       "test_command\"",
+		lnSupportedCommands:  nil,
+		lnExpectedCommandReq: nil,
+		lnResponse:           nil,
+		lnError:              nil,
+		apiExpectedResponse:  nil,
+		apiExpectedErr:       "failed to parse node command",
+	}
+
+	// Error: node does not support this command.
+	testCaseErrUnknownCommand := testCase{
+		name:                 "unknown command",
+		apiCommandLine:       "test_command_unknown",
+		lnSupportedCommands:  []lnclient.CustomNodeCommandDef{{Name: "test_command"}},
+		lnExpectedCommandReq: nil,
+		lnResponse:           nil,
+		lnError:              nil,
+		apiExpectedResponse:  nil,
+		apiExpectedErr:       "unknown command",
+	}
+
+	// Error: unsupported command argument.
+	testCaseErrUnknownArg := testCase{
+		name:                 "unknown argument",
+		apiCommandLine:       "test_command --unknown=fail",
+		lnSupportedCommands:  []lnclient.CustomNodeCommandDef{{Name: "test_command"}},
+		lnExpectedCommandReq: nil,
+		lnResponse:           nil,
+		lnError:              nil,
+		apiExpectedResponse:  nil,
+		apiExpectedErr:       "flag provided but not defined: -unknown",
+	}
+
+	// Error: the command is valid but the node fails to execute it.
+	testCaseErrNodeFailed := testCase{
+		name:                 "node failed to execute command",
+		apiCommandLine:       "test_command",
+		lnSupportedCommands:  []lnclient.CustomNodeCommandDef{{Name: "test_command"}},
+		lnExpectedCommandReq: &lnclient.CustomNodeCommandRequest{Name: "test_command", Args: []lnclient.CustomNodeCommandArg{}},
+		lnResponse:           nil,
+		lnError:              fmt.Errorf("utter failure"),
+		apiExpectedResponse:  nil,
+		apiExpectedErr:       "utter failure",
+	}
+
+	testCases := []testCase{
+		testCaseOkNoArgs,
+		testCaseOkWithArgs,
+		testCaseOkWithUnsetArg,
+		testCaseErrEmptyCommand,
+		testCaseErrMalformedCommand,
+		testCaseErrUnknownCommand,
+		testCaseErrUnknownArg,
+		testCaseErrNodeFailed,
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			lnClient := mocks.NewMockLNClient(t)
+			svc := mocks.NewMockService(t)
+
+			if tc.lnSupportedCommands != nil {
+				lnClient.On("GetCustomNodeCommandDefinitions").Return(tc.lnSupportedCommands)
+			}
+
+			if tc.lnExpectedCommandReq != nil {
+				lnClient.On("ExecuteCustomNodeCommand", mock.Anything, tc.lnExpectedCommandReq).Return(tc.lnResponse, tc.lnError)
+			}
+
+			svc.On("GetLNClient").Return(lnClient)
+
+			theAPI := instantiateAPIWithService(svc)
+
+			response, err := theAPI.ExecuteCustomNodeCommand(context.TODO(), tc.apiCommandLine)
+			require.Equal(t, tc.apiExpectedResponse, response)
+			if tc.apiExpectedErr == "" {
+				require.NoError(t, err)
+			} else {
+				require.ErrorContains(t, err, tc.apiExpectedErr)
+			}
+		})
+	}
+}
+
+// instantiateAPIWithService is a helper function that returns a partially
+// constructed API instance. It is only suitable for the simplest of test cases.
+func instantiateAPIWithService(s service.Service) *api {
+	return &api{svc: s}
+}
diff --git a/api/models.go b/api/models.go
index 73593f906..8f68613ce 100644
--- a/api/models.go
+++ b/api/models.go
@@ -57,6 +57,8 @@ type API interface {
 	MigrateNodeStorage(ctx context.Context, to string) error
 	GetWalletCapabilities(ctx context.Context) (*WalletCapabilitiesResponse, error)
 	Health(ctx context.Context) (*HealthResponse, error)
+	GetCustomNodeCommands() (*CustomNodeCommandsResponse, error)
+	ExecuteCustomNodeCommand(ctx context.Context, command string) (interface{}, error)
 }
 
 type App struct {
@@ -392,3 +394,22 @@ func NewHealthAlarm(kind HealthAlarmKind, rawDetails any) HealthAlarm {
 type HealthResponse struct {
 	Alarms []HealthAlarm `json:"alarms,omitempty"`
 }
+
+type CustomNodeCommandArgDef struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+}
+
+type CustomNodeCommandDef struct {
+	Name        string                    `json:"name"`
+	Description string                    `json:"description"`
+	Args        []CustomNodeCommandArgDef `json:"args"`
+}
+
+type CustomNodeCommandsResponse struct {
+	Commands []CustomNodeCommandDef `json:"commands"`
+}
+
+type ExecuteCustomNodeCommandRequest struct {
+	Command string `json:"command"`
+}
diff --git a/frontend/src/components/ExecuteCustomNodeCommandDialogContent.tsx b/frontend/src/components/ExecuteCustomNodeCommandDialogContent.tsx
new file mode 100644
index 000000000..d174c2f9b
--- /dev/null
+++ b/frontend/src/components/ExecuteCustomNodeCommandDialogContent.tsx
@@ -0,0 +1,98 @@
+import React from "react";
+import {
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "src/components/ui/alert-dialog";
+import { Textarea } from "src/components/ui/textarea";
+import { useToast } from "src/components/ui/use-toast";
+import { useInfo } from "src/hooks/useInfo";
+import { request } from "src/utils/request";
+
+type ExecuteCustomNodeCommandDialogContentProps = {
+  availableCommands: string;
+  setCommandResponse: (response: string) => void;
+};
+
+export function ExecuteCustomNodeCommandDialogContent({
+  setCommandResponse,
+  availableCommands,
+}: ExecuteCustomNodeCommandDialogContentProps) {
+  const { mutate: reloadInfo } = useInfo();
+  const { toast } = useToast();
+  const [command, setCommand] = React.useState<string>();
+
+  let parsedAvailableCommands = availableCommands;
+  try {
+    parsedAvailableCommands = JSON.stringify(
+      JSON.parse(availableCommands).commands,
+      null,
+      2
+    );
+  } catch (error) {
+    // ignore unexpected json
+  }
+
+  async function onSubmit(e: React.FormEvent) {
+    e.preventDefault();
+    try {
+      if (!command) {
+        throw new Error("No command set");
+      }
+      const result = await request("/api/command", {
+        method: "POST",
+        body: JSON.stringify({ command }),
+        headers: {
+          "Content-Type": "application/json",
+        },
+      });
+      await reloadInfo();
+
+      const parsedResponse = JSON.stringify(result);
+      setCommandResponse(parsedResponse);
+
+      toast({ title: "Command executed", description: parsedResponse });
+    } catch (error) {
+      console.error(error);
+      toast({
+        variant: "destructive",
+        title: "Something went wrong: " + error,
+      });
+    }
+  }
+
+  return (
+    <AlertDialogContent>
+      <form onSubmit={onSubmit}>
+        <AlertDialogHeader>
+          <AlertDialogTitle>Execute Custom Node Command</AlertDialogTitle>
+          <AlertDialogDescription className="text-left">
+            <Textarea
+              className="h-36 font-mono"
+              value={command}
+              onChange={(e) => setCommand(e.target.value)}
+              placeholder="commandname --arg1=value1"
+            />
+            <p className="mt-2">Available commands</p>
+            <Textarea
+              readOnly
+              className="mt-2 font-mono"
+              value={parsedAvailableCommands}
+              rows={10}
+            />
+          </AlertDialogDescription>
+        </AlertDialogHeader>
+        <AlertDialogFooter className="mt-4">
+          <AlertDialogCancel onClick={() => setCommand("")}>
+            Cancel
+          </AlertDialogCancel>
+          <AlertDialogAction type="submit">Execute</AlertDialogAction>
+        </AlertDialogFooter>
+      </form>
+    </AlertDialogContent>
+  );
+}
diff --git a/frontend/src/screens/settings/DebugTools.tsx b/frontend/src/screens/settings/DebugTools.tsx
index 2895408be..061f72408 100644
--- a/frontend/src/screens/settings/DebugTools.tsx
+++ b/frontend/src/screens/settings/DebugTools.tsx
@@ -1,4 +1,5 @@
 import React from "react";
+import { ExecuteCustomNodeCommandDialogContent } from "src/components/ExecuteCustomNodeCommandDialogContent";
 import { ResetRoutingDataDialogContent } from "src/components/ResetRoutingDataDialogContent";
 import SettingsHeader from "src/components/SettingsHeader";
 import {
@@ -221,6 +222,7 @@ export default function DebugTools() {
     | "getNodeLogs"
     | "getNetworkGraph"
     | "resetRoutingData"
+    | "customNodeCommand"
   >();
 
   const { data: info } = useInfo();
@@ -311,6 +313,23 @@ export default function DebugTools() {
               </Button>
             </AlertDialogTrigger>
           )}
+          <Button
+            onClick={() => {
+              apiRequest(`/api/commands`, "GET");
+            }}
+          >
+            Get Node Commands
+          </Button>
+          <AlertDialogTrigger asChild>
+            <Button
+              onClick={() => {
+                apiRequest(`/api/commands`, "GET");
+                setDialog("customNodeCommand");
+              }}
+            >
+              Execute Node Command
+            </Button>
+          </AlertDialogTrigger>
           {/* probing functions are not useful */}
           {/*info?.backendType === "LDK" && (
             <AlertDialogTrigger asChild>
@@ -343,6 +362,12 @@ export default function DebugTools() {
             <GetNetworkGraphDialogContent apiRequest={apiRequest} />
           )}
           {dialog === "resetRoutingData" && <ResetRoutingDataDialogContent />}
+          {dialog === "customNodeCommand" && (
+            <ExecuteCustomNodeCommandDialogContent
+              availableCommands={apiResponse}
+              setCommandResponse={setApiResponse}
+            />
+          )}
         </AlertDialog>
       </div>
       {apiResponse && (
diff --git a/http/http_service.go b/http/http_service.go
index 7b72af8f4..833732f6d 100644
--- a/http/http_service.go
+++ b/http/http_service.go
@@ -154,6 +154,8 @@ func (httpSvc *HttpService) RegisterSharedRoutes(e *echo.Echo) {
 	restrictedGroup.POST("/api/send-spontaneous-payment-probes", httpSvc.sendSpontaneousPaymentProbesHandler)
 	restrictedGroup.GET("/api/log/:type", httpSvc.getLogOutputHandler)
 	restrictedGroup.GET("/api/health", httpSvc.healthHandler)
+	restrictedGroup.GET("/api/commands", httpSvc.getCustomNodeCommandsHandler)
+	restrictedGroup.POST("/api/command", httpSvc.execCustomNodeCommandHandler)
 
 	httpSvc.albyHttpSvc.RegisterSharedRoutes(restrictedGroup, e)
 }
@@ -999,6 +1001,35 @@ func (httpSvc *HttpService) getLogOutputHandler(c echo.Context) error {
 	return c.JSON(http.StatusOK, getLogResponse)
 }
 
+func (httpSvc *HttpService) getCustomNodeCommandsHandler(c echo.Context) error {
+	nodeCommandsResponse, err := httpSvc.api.GetCustomNodeCommands()
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, ErrorResponse{
+			Message: fmt.Sprintf("Failed to get node commands: %v", err),
+		})
+	}
+
+	return c.JSON(http.StatusOK, nodeCommandsResponse)
+}
+
+func (httpSvc *HttpService) execCustomNodeCommandHandler(c echo.Context) error {
+	var execCommandRequest api.ExecuteCustomNodeCommandRequest
+	if err := c.Bind(&execCommandRequest); err != nil {
+		return c.JSON(http.StatusBadRequest, ErrorResponse{
+			Message: fmt.Sprintf("Bad request: %s", err.Error()),
+		})
+	}
+
+	execCommandResponse, err := httpSvc.api.ExecuteCustomNodeCommand(c.Request().Context(), execCommandRequest.Command)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, ErrorResponse{
+			Message: fmt.Sprintf("Failed to execute command: %v", err),
+		})
+	}
+
+	return c.JSON(http.StatusOK, execCommandResponse)
+}
+
 func (httpSvc *HttpService) logoutHandler(c echo.Context) error {
 	redirectUrl := httpSvc.cfg.GetEnv().FrontendUrl
 	if redirectUrl == "" {
diff --git a/lnclient/breez/breez.go b/lnclient/breez/breez.go
index 37a04b5a2..cbfaa347e 100644
--- a/lnclient/breez/breez.go
+++ b/lnclient/breez/breez.go
@@ -46,7 +46,7 @@ func NewBreezService(mnemonic, apiKey, inviteCode, workDir string) (result lncli
 		return nil, errors.New("one or more required breez configuration are missing")
 	}
 
-	//create dir if not exists
+	// create dir if not exists
 	newpath := filepath.Join(workDir)
 	err = os.MkdirAll(newpath, os.ModePerm)
 	if err != nil {
@@ -493,3 +493,11 @@ func (bs *BreezService) GetSupportedNIP47NotificationTypes() []string {
 func (bs *BreezService) GetPubkey() string {
 	return bs.pubkey
 }
+
+func (bs *BreezService) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
+	return nil
+}
+
+func (bs *BreezService) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
+	return nil, nil
+}
diff --git a/lnclient/cashu/cashu.go b/lnclient/cashu/cashu.go
index 4febb000f..59a2e9044 100644
--- a/lnclient/cashu/cashu.go
+++ b/lnclient/cashu/cashu.go
@@ -11,12 +11,16 @@ import (
 
 	"github.com/elnosh/gonuts/wallet"
 	"github.com/elnosh/gonuts/wallet/storage"
-	"github.com/getAlby/hub/lnclient"
-	"github.com/getAlby/hub/logger"
 	decodepay "github.com/nbd-wtf/ln-decodepay"
 	"github.com/sirupsen/logrus"
+
+	"github.com/getAlby/hub/lnclient"
+	"github.com/getAlby/hub/logger"
 )
 
+const nodeCommandRestore = "restore"
+const exampleCommandWithArg = "example"
+
 type CashuService struct {
 	wallet *wallet.Wallet
 }
@@ -29,7 +33,7 @@ func NewCashuService(workDir string, mintUrl string) (result lnclient.LNClient,
 		return nil, errors.New("no mint URL configured")
 	}
 
-	//create dir if not exists
+	// create dir if not exists
 	newpath := filepath.Join(workDir)
 	_, err = os.Stat(newpath)
 	isFirstSetup := err != nil && errors.Is(err, os.ErrNotExist)
@@ -375,3 +379,67 @@ func (cs *CashuService) GetSupportedNIP47NotificationTypes() []string {
 func (svc *CashuService) GetPubkey() string {
 	return ""
 }
+
+func (cs *CashuService) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
+	return []lnclient.CustomNodeCommandDef{
+		{
+			Name:        nodeCommandRestore,
+			Description: "Restore cashu tokens after the wallet had a stuck payment.",
+			Args:        nil,
+		},
+		{
+			Name:        exampleCommandWithArg,
+			Description: "Example command with argument",
+			Args: []lnclient.CustomNodeCommandArgDef{
+				{
+					Name:        "hello",
+					Description: "world",
+				},
+			},
+		},
+	}
+}
+
+func (cs *CashuService) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
+	switch command.Name {
+	case nodeCommandRestore:
+		return cs.executeCommandRestore(ctx)
+	case exampleCommandWithArg:
+		if len(command.Args) != 1 {
+			return nil, errors.New("please provide an argument")
+		}
+
+		return &lnclient.CustomNodeCommandResponse{
+			Response: map[string]string{
+				command.Args[0].Name: command.Args[0].Value,
+			},
+		}, nil
+	}
+
+	return nil, lnclient.ErrUnknownCustomNodeCommand
+}
+
+func (cs *CashuService) executeCommandRestore(ctx context.Context) (*lnclient.CustomNodeCommandResponse, error) {
+	// FIXME: needs latest Cashu changes to be merged
+	// mnemonic := cs.wallet.Mnemonic()
+	// currentMint := cs.wallet.CurrentMint()
+	//
+	// if err := cs.wallet.Shutdown(); err != nil {
+	// 	return nil, err
+	// }
+	//
+	// if err := os.RemoveAll(cs.workDir); err != nil {
+	// 	logger.Logger.WithError(err).Error("Failed to remove wallet directory")
+	// 	return nil, err
+	// }
+	//
+	// amountRestored, err := wallet.Restore(cs.workDir, mnemonic, []string{currentMint})
+	// if err != nil {
+	// 	logger.Logger.WithError(err).Error("Failed restore cashu wallet")
+	// 	return nil, err
+	// }
+	//
+	// logger.Logger.WithField("amountRestored", amountRestored).Info("Successfully restored cashu wallet")
+
+	return lnclient.NewCustomNodeCommandResponseEmpty(), nil
+}
diff --git a/lnclient/greenlight/greenlight.go b/lnclient/greenlight/greenlight.go
index 5f76b6a0d..48e611900 100644
--- a/lnclient/greenlight/greenlight.go
+++ b/lnclient/greenlight/greenlight.go
@@ -12,7 +12,7 @@ import (
 	"strings"
 	"time"
 
-	//"github.com/getAlby/hub/glalby" // for local development only
+	// "github.com/getAlby/hub/glalby" // for local development only
 
 	"github.com/getAlby/glalby-go/glalby"
 	decodepay "github.com/nbd-wtf/ln-decodepay"
@@ -36,7 +36,7 @@ func NewGreenlightService(cfg config.Config, mnemonic, inviteCode, workDir, encr
 		return nil, errors.New("one or more required greenlight configuration are missing")
 	}
 
-	//create dir if not exists
+	// create dir if not exists
 	newpath := filepath.Join(workDir)
 	err = os.MkdirAll(newpath, os.ModePerm)
 	if err != nil {
@@ -689,3 +689,11 @@ func (gs *GreenlightService) GetSupportedNIP47NotificationTypes() []string {
 func (gs *GreenlightService) GetPubkey() string {
 	return gs.pubkey
 }
+
+func (gs *GreenlightService) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
+	return nil
+}
+
+func (gs *GreenlightService) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
+	return nil, nil
+}
diff --git a/lnclient/ldk/ldk.go b/lnclient/ldk/ldk.go
index 438050bf2..9b84db4ff 100644
--- a/lnclient/ldk/ldk.go
+++ b/lnclient/ldk/ldk.go
@@ -1736,6 +1736,14 @@ func (ls *LDKService) GetPubkey() string {
 	return ls.pubkey
 }
 
+func (ls *LDKService) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
+	return nil
+}
+
+func (ls *LDKService) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
+	return nil, nil
+}
+
 func getEncodedChannelMonitorsFromStaticChannelsBackup(channelsBackup *events.StaticChannelsBackupEvent) []ldk_node.KeyValue {
 	encodedMonitors := []ldk_node.KeyValue{}
 	for _, monitor := range channelsBackup.Monitors {
diff --git a/lnclient/lnd/lnd.go b/lnclient/lnd/lnd.go
index 4c630802c..e91fb599c 100644
--- a/lnclient/lnd/lnd.go
+++ b/lnclient/lnd/lnd.go
@@ -1264,3 +1264,11 @@ func (svc *LNDService) GetStorageDir() (string, error) {
 }
 
 func (svc *LNDService) UpdateLastWalletSyncRequest() {}
+
+func (svc *LNDService) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
+	return nil
+}
+
+func (svc *LNDService) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
+	return nil, nil
+}
diff --git a/lnclient/models.go b/lnclient/models.go
index 25f1cf0c5..57db7e50f 100644
--- a/lnclient/models.go
+++ b/lnclient/models.go
@@ -2,6 +2,7 @@ package lnclient
 
 import (
 	"context"
+	"errors"
 )
 
 // TODO: remove JSON tags from these models (LNClient models should not be exposed directly)
@@ -77,6 +78,8 @@ type LNClient interface {
 	UpdateLastWalletSyncRequest()
 	GetSupportedNIP47Methods() []string
 	GetSupportedNIP47NotificationTypes() []string
+	GetCustomNodeCommandDefinitions() []CustomNodeCommandDef
+	ExecuteCustomNodeCommand(ctx context.Context, command *CustomNodeCommandRequest) (*CustomNodeCommandResponse, error)
 }
 
 type Channel struct {
@@ -189,6 +192,39 @@ type PaymentFailedEventProperties struct {
 	Reason      string
 }
 
+type CustomNodeCommandArgDef struct {
+	Name        string
+	Description string
+}
+
+type CustomNodeCommandDef struct {
+	Name        string
+	Description string
+	Args        []CustomNodeCommandArgDef
+}
+
+type CustomNodeCommandArg struct {
+	Name  string
+	Value string
+}
+
+type CustomNodeCommandRequest struct {
+	Name string
+	Args []CustomNodeCommandArg
+}
+
+type CustomNodeCommandResponse struct {
+	Response interface{}
+}
+
+func NewCustomNodeCommandResponseEmpty() *CustomNodeCommandResponse {
+	return &CustomNodeCommandResponse{
+		Response: struct{}{},
+	}
+}
+
+var ErrUnknownCustomNodeCommand = errors.New("unknown custom node command")
+
 // default invoice expiry in seconds (1 day)
 const DEFAULT_INVOICE_EXPIRY = 86400
 
diff --git a/lnclient/phoenixd/phoenixd.go b/lnclient/phoenixd/phoenixd.go
index 7f40cfe8c..c565d657a 100644
--- a/lnclient/phoenixd/phoenixd.go
+++ b/lnclient/phoenixd/phoenixd.go
@@ -12,9 +12,10 @@ import (
 	"strings"
 	"time"
 
+	decodepay "github.com/nbd-wtf/ln-decodepay"
+
 	"github.com/getAlby/hub/lnclient"
 	"github.com/getAlby/hub/logger"
-	decodepay "github.com/nbd-wtf/ln-decodepay"
 
 	"github.com/sirupsen/logrus"
 )
@@ -541,3 +542,11 @@ func (svc *PhoenixService) GetSupportedNIP47NotificationTypes() []string {
 func (svc *PhoenixService) GetPubkey() string {
 	return svc.pubkey
 }
+
+func (svc *PhoenixService) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
+	return nil
+}
+
+func (svc *PhoenixService) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
+	return nil, nil
+}
diff --git a/tests/mock_ln_client.go b/tests/mock_ln_client.go
index e6e30af6d..2d19e6f5c 100644
--- a/tests/mock_ln_client.go
+++ b/tests/mock_ln_client.go
@@ -203,3 +203,11 @@ func (mln *MockLn) GetPubkey() string {
 
 	return "123pubkey"
 }
+
+func (mln *MockLn) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
+	return nil
+}
+
+func (mln *MockLn) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
+	return nil, nil
+}
diff --git a/tests/mocks/LNClient.go b/tests/mocks/LNClient.go
new file mode 100644
index 000000000..fecf32ef9
--- /dev/null
+++ b/tests/mocks/LNClient.go
@@ -0,0 +1,1817 @@
+// Code generated by mockery v2.51.1. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+
+	lnclient "github.com/getAlby/hub/lnclient"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockLNClient is an autogenerated mock type for the LNClient type
+type MockLNClient struct {
+	mock.Mock
+}
+
+type MockLNClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockLNClient) EXPECT() *MockLNClient_Expecter {
+	return &MockLNClient_Expecter{mock: &_m.Mock}
+}
+
+// CloseChannel provides a mock function with given fields: ctx, closeChannelRequest
+func (_m *MockLNClient) CloseChannel(ctx context.Context, closeChannelRequest *lnclient.CloseChannelRequest) (*lnclient.CloseChannelResponse, error) {
+	ret := _m.Called(ctx, closeChannelRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CloseChannel")
+	}
+
+	var r0 *lnclient.CloseChannelResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *lnclient.CloseChannelRequest) (*lnclient.CloseChannelResponse, error)); ok {
+		return rf(ctx, closeChannelRequest)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *lnclient.CloseChannelRequest) *lnclient.CloseChannelResponse); ok {
+		r0 = rf(ctx, closeChannelRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.CloseChannelResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *lnclient.CloseChannelRequest) error); ok {
+		r1 = rf(ctx, closeChannelRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_CloseChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseChannel'
+type MockLNClient_CloseChannel_Call struct {
+	*mock.Call
+}
+
+// CloseChannel is a helper method to define mock.On call
+//   - ctx context.Context
+//   - closeChannelRequest *lnclient.CloseChannelRequest
+func (_e *MockLNClient_Expecter) CloseChannel(ctx interface{}, closeChannelRequest interface{}) *MockLNClient_CloseChannel_Call {
+	return &MockLNClient_CloseChannel_Call{Call: _e.mock.On("CloseChannel", ctx, closeChannelRequest)}
+}
+
+func (_c *MockLNClient_CloseChannel_Call) Run(run func(ctx context.Context, closeChannelRequest *lnclient.CloseChannelRequest)) *MockLNClient_CloseChannel_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*lnclient.CloseChannelRequest))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_CloseChannel_Call) Return(_a0 *lnclient.CloseChannelResponse, _a1 error) *MockLNClient_CloseChannel_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_CloseChannel_Call) RunAndReturn(run func(context.Context, *lnclient.CloseChannelRequest) (*lnclient.CloseChannelResponse, error)) *MockLNClient_CloseChannel_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ConnectPeer provides a mock function with given fields: ctx, connectPeerRequest
+func (_m *MockLNClient) ConnectPeer(ctx context.Context, connectPeerRequest *lnclient.ConnectPeerRequest) error {
+	ret := _m.Called(ctx, connectPeerRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConnectPeer")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, *lnclient.ConnectPeerRequest) error); ok {
+		r0 = rf(ctx, connectPeerRequest)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockLNClient_ConnectPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectPeer'
+type MockLNClient_ConnectPeer_Call struct {
+	*mock.Call
+}
+
+// ConnectPeer is a helper method to define mock.On call
+//   - ctx context.Context
+//   - connectPeerRequest *lnclient.ConnectPeerRequest
+func (_e *MockLNClient_Expecter) ConnectPeer(ctx interface{}, connectPeerRequest interface{}) *MockLNClient_ConnectPeer_Call {
+	return &MockLNClient_ConnectPeer_Call{Call: _e.mock.On("ConnectPeer", ctx, connectPeerRequest)}
+}
+
+func (_c *MockLNClient_ConnectPeer_Call) Run(run func(ctx context.Context, connectPeerRequest *lnclient.ConnectPeerRequest)) *MockLNClient_ConnectPeer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*lnclient.ConnectPeerRequest))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_ConnectPeer_Call) Return(_a0 error) *MockLNClient_ConnectPeer_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_ConnectPeer_Call) RunAndReturn(run func(context.Context, *lnclient.ConnectPeerRequest) error) *MockLNClient_ConnectPeer_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DisconnectPeer provides a mock function with given fields: ctx, peerId
+func (_m *MockLNClient) DisconnectPeer(ctx context.Context, peerId string) error {
+	ret := _m.Called(ctx, peerId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DisconnectPeer")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
+		r0 = rf(ctx, peerId)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockLNClient_DisconnectPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectPeer'
+type MockLNClient_DisconnectPeer_Call struct {
+	*mock.Call
+}
+
+// DisconnectPeer is a helper method to define mock.On call
+//   - ctx context.Context
+//   - peerId string
+func (_e *MockLNClient_Expecter) DisconnectPeer(ctx interface{}, peerId interface{}) *MockLNClient_DisconnectPeer_Call {
+	return &MockLNClient_DisconnectPeer_Call{Call: _e.mock.On("DisconnectPeer", ctx, peerId)}
+}
+
+func (_c *MockLNClient_DisconnectPeer_Call) Run(run func(ctx context.Context, peerId string)) *MockLNClient_DisconnectPeer_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_DisconnectPeer_Call) Return(_a0 error) *MockLNClient_DisconnectPeer_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_DisconnectPeer_Call) RunAndReturn(run func(context.Context, string) error) *MockLNClient_DisconnectPeer_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ExecuteCustomNodeCommand provides a mock function with given fields: ctx, command
+func (_m *MockLNClient) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
+	ret := _m.Called(ctx, command)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ExecuteCustomNodeCommand")
+	}
+
+	var r0 *lnclient.CustomNodeCommandResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error)); ok {
+		return rf(ctx, command)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *lnclient.CustomNodeCommandRequest) *lnclient.CustomNodeCommandResponse); ok {
+		r0 = rf(ctx, command)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.CustomNodeCommandResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *lnclient.CustomNodeCommandRequest) error); ok {
+		r1 = rf(ctx, command)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_ExecuteCustomNodeCommand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteCustomNodeCommand'
+type MockLNClient_ExecuteCustomNodeCommand_Call struct {
+	*mock.Call
+}
+
+// ExecuteCustomNodeCommand is a helper method to define mock.On call
+//   - ctx context.Context
+//   - command *lnclient.CustomNodeCommandRequest
+func (_e *MockLNClient_Expecter) ExecuteCustomNodeCommand(ctx interface{}, command interface{}) *MockLNClient_ExecuteCustomNodeCommand_Call {
+	return &MockLNClient_ExecuteCustomNodeCommand_Call{Call: _e.mock.On("ExecuteCustomNodeCommand", ctx, command)}
+}
+
+func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) Run(run func(ctx context.Context, command *lnclient.CustomNodeCommandRequest)) *MockLNClient_ExecuteCustomNodeCommand_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*lnclient.CustomNodeCommandRequest))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) Return(_a0 *lnclient.CustomNodeCommandResponse, _a1 error) *MockLNClient_ExecuteCustomNodeCommand_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) RunAndReturn(run func(context.Context, *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error)) *MockLNClient_ExecuteCustomNodeCommand_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetBalances provides a mock function with given fields: ctx
+func (_m *MockLNClient) GetBalances(ctx context.Context) (*lnclient.BalancesResponse, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetBalances")
+	}
+
+	var r0 *lnclient.BalancesResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) (*lnclient.BalancesResponse, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) *lnclient.BalancesResponse); ok {
+		r0 = rf(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.BalancesResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetBalances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBalances'
+type MockLNClient_GetBalances_Call struct {
+	*mock.Call
+}
+
+// GetBalances is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockLNClient_Expecter) GetBalances(ctx interface{}) *MockLNClient_GetBalances_Call {
+	return &MockLNClient_GetBalances_Call{Call: _e.mock.On("GetBalances", ctx)}
+}
+
+func (_c *MockLNClient_GetBalances_Call) Run(run func(ctx context.Context)) *MockLNClient_GetBalances_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetBalances_Call) Return(_a0 *lnclient.BalancesResponse, _a1 error) *MockLNClient_GetBalances_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_GetBalances_Call) RunAndReturn(run func(context.Context) (*lnclient.BalancesResponse, error)) *MockLNClient_GetBalances_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetCustomNodeCommandDefinitions provides a mock function with no fields
+func (_m *MockLNClient) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetCustomNodeCommandDefinitions")
+	}
+
+	var r0 []lnclient.CustomNodeCommandDef
+	if rf, ok := ret.Get(0).(func() []lnclient.CustomNodeCommandDef); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]lnclient.CustomNodeCommandDef)
+		}
+	}
+
+	return r0
+}
+
+// MockLNClient_GetCustomNodeCommandDefinitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCustomNodeCommandDefinitions'
+type MockLNClient_GetCustomNodeCommandDefinitions_Call struct {
+	*mock.Call
+}
+
+// GetCustomNodeCommandDefinitions is a helper method to define mock.On call
+func (_e *MockLNClient_Expecter) GetCustomNodeCommandDefinitions() *MockLNClient_GetCustomNodeCommandDefinitions_Call {
+	return &MockLNClient_GetCustomNodeCommandDefinitions_Call{Call: _e.mock.On("GetCustomNodeCommandDefinitions")}
+}
+
+func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) Run(run func()) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) Return(_a0 []lnclient.CustomNodeCommandDef) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) RunAndReturn(run func() []lnclient.CustomNodeCommandDef) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetInfo provides a mock function with given fields: ctx
+func (_m *MockLNClient) GetInfo(ctx context.Context) (*lnclient.NodeInfo, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetInfo")
+	}
+
+	var r0 *lnclient.NodeInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeInfo, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) *lnclient.NodeInfo); ok {
+		r0 = rf(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.NodeInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInfo'
+type MockLNClient_GetInfo_Call struct {
+	*mock.Call
+}
+
+// GetInfo is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockLNClient_Expecter) GetInfo(ctx interface{}) *MockLNClient_GetInfo_Call {
+	return &MockLNClient_GetInfo_Call{Call: _e.mock.On("GetInfo", ctx)}
+}
+
+func (_c *MockLNClient_GetInfo_Call) Run(run func(ctx context.Context)) *MockLNClient_GetInfo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetInfo_Call) Return(info *lnclient.NodeInfo, err error) *MockLNClient_GetInfo_Call {
+	_c.Call.Return(info, err)
+	return _c
+}
+
+func (_c *MockLNClient_GetInfo_Call) RunAndReturn(run func(context.Context) (*lnclient.NodeInfo, error)) *MockLNClient_GetInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetLogOutput provides a mock function with given fields: ctx, maxLen
+func (_m *MockLNClient) GetLogOutput(ctx context.Context, maxLen int) ([]byte, error) {
+	ret := _m.Called(ctx, maxLen)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLogOutput")
+	}
+
+	var r0 []byte
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, int) ([]byte, error)); ok {
+		return rf(ctx, maxLen)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, int) []byte); ok {
+		r0 = rf(ctx, maxLen)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, int) error); ok {
+		r1 = rf(ctx, maxLen)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetLogOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLogOutput'
+type MockLNClient_GetLogOutput_Call struct {
+	*mock.Call
+}
+
+// GetLogOutput is a helper method to define mock.On call
+//   - ctx context.Context
+//   - maxLen int
+func (_e *MockLNClient_Expecter) GetLogOutput(ctx interface{}, maxLen interface{}) *MockLNClient_GetLogOutput_Call {
+	return &MockLNClient_GetLogOutput_Call{Call: _e.mock.On("GetLogOutput", ctx, maxLen)}
+}
+
+func (_c *MockLNClient_GetLogOutput_Call) Run(run func(ctx context.Context, maxLen int)) *MockLNClient_GetLogOutput_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(int))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetLogOutput_Call) Return(_a0 []byte, _a1 error) *MockLNClient_GetLogOutput_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_GetLogOutput_Call) RunAndReturn(run func(context.Context, int) ([]byte, error)) *MockLNClient_GetLogOutput_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetNetworkGraph provides a mock function with given fields: ctx, nodeIds
+func (_m *MockLNClient) GetNetworkGraph(ctx context.Context, nodeIds []string) (lnclient.NetworkGraphResponse, error) {
+	ret := _m.Called(ctx, nodeIds)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetNetworkGraph")
+	}
+
+	var r0 lnclient.NetworkGraphResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, []string) (lnclient.NetworkGraphResponse, error)); ok {
+		return rf(ctx, nodeIds)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, []string) lnclient.NetworkGraphResponse); ok {
+		r0 = rf(ctx, nodeIds)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(lnclient.NetworkGraphResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
+		r1 = rf(ctx, nodeIds)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetNetworkGraph_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetworkGraph'
+type MockLNClient_GetNetworkGraph_Call struct {
+	*mock.Call
+}
+
+// GetNetworkGraph is a helper method to define mock.On call
+//   - ctx context.Context
+//   - nodeIds []string
+func (_e *MockLNClient_Expecter) GetNetworkGraph(ctx interface{}, nodeIds interface{}) *MockLNClient_GetNetworkGraph_Call {
+	return &MockLNClient_GetNetworkGraph_Call{Call: _e.mock.On("GetNetworkGraph", ctx, nodeIds)}
+}
+
+func (_c *MockLNClient_GetNetworkGraph_Call) Run(run func(ctx context.Context, nodeIds []string)) *MockLNClient_GetNetworkGraph_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].([]string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetNetworkGraph_Call) Return(_a0 lnclient.NetworkGraphResponse, _a1 error) *MockLNClient_GetNetworkGraph_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_GetNetworkGraph_Call) RunAndReturn(run func(context.Context, []string) (lnclient.NetworkGraphResponse, error)) *MockLNClient_GetNetworkGraph_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetNewOnchainAddress provides a mock function with given fields: ctx
+func (_m *MockLNClient) GetNewOnchainAddress(ctx context.Context) (string, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetNewOnchainAddress")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) string); ok {
+		r0 = rf(ctx)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetNewOnchainAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNewOnchainAddress'
+type MockLNClient_GetNewOnchainAddress_Call struct {
+	*mock.Call
+}
+
+// GetNewOnchainAddress is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockLNClient_Expecter) GetNewOnchainAddress(ctx interface{}) *MockLNClient_GetNewOnchainAddress_Call {
+	return &MockLNClient_GetNewOnchainAddress_Call{Call: _e.mock.On("GetNewOnchainAddress", ctx)}
+}
+
+func (_c *MockLNClient_GetNewOnchainAddress_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNewOnchainAddress_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetNewOnchainAddress_Call) Return(_a0 string, _a1 error) *MockLNClient_GetNewOnchainAddress_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_GetNewOnchainAddress_Call) RunAndReturn(run func(context.Context) (string, error)) *MockLNClient_GetNewOnchainAddress_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetNodeConnectionInfo provides a mock function with given fields: ctx
+func (_m *MockLNClient) GetNodeConnectionInfo(ctx context.Context) (*lnclient.NodeConnectionInfo, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetNodeConnectionInfo")
+	}
+
+	var r0 *lnclient.NodeConnectionInfo
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeConnectionInfo, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) *lnclient.NodeConnectionInfo); ok {
+		r0 = rf(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.NodeConnectionInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetNodeConnectionInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodeConnectionInfo'
+type MockLNClient_GetNodeConnectionInfo_Call struct {
+	*mock.Call
+}
+
+// GetNodeConnectionInfo is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockLNClient_Expecter) GetNodeConnectionInfo(ctx interface{}) *MockLNClient_GetNodeConnectionInfo_Call {
+	return &MockLNClient_GetNodeConnectionInfo_Call{Call: _e.mock.On("GetNodeConnectionInfo", ctx)}
+}
+
+func (_c *MockLNClient_GetNodeConnectionInfo_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNodeConnectionInfo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetNodeConnectionInfo_Call) Return(nodeConnectionInfo *lnclient.NodeConnectionInfo, err error) *MockLNClient_GetNodeConnectionInfo_Call {
+	_c.Call.Return(nodeConnectionInfo, err)
+	return _c
+}
+
+func (_c *MockLNClient_GetNodeConnectionInfo_Call) RunAndReturn(run func(context.Context) (*lnclient.NodeConnectionInfo, error)) *MockLNClient_GetNodeConnectionInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetNodeStatus provides a mock function with given fields: ctx
+func (_m *MockLNClient) GetNodeStatus(ctx context.Context) (*lnclient.NodeStatus, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetNodeStatus")
+	}
+
+	var r0 *lnclient.NodeStatus
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeStatus, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) *lnclient.NodeStatus); ok {
+		r0 = rf(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.NodeStatus)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetNodeStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodeStatus'
+type MockLNClient_GetNodeStatus_Call struct {
+	*mock.Call
+}
+
+// GetNodeStatus is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockLNClient_Expecter) GetNodeStatus(ctx interface{}) *MockLNClient_GetNodeStatus_Call {
+	return &MockLNClient_GetNodeStatus_Call{Call: _e.mock.On("GetNodeStatus", ctx)}
+}
+
+func (_c *MockLNClient_GetNodeStatus_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNodeStatus_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetNodeStatus_Call) Return(nodeStatus *lnclient.NodeStatus, err error) *MockLNClient_GetNodeStatus_Call {
+	_c.Call.Return(nodeStatus, err)
+	return _c
+}
+
+func (_c *MockLNClient_GetNodeStatus_Call) RunAndReturn(run func(context.Context) (*lnclient.NodeStatus, error)) *MockLNClient_GetNodeStatus_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetOnchainBalance provides a mock function with given fields: ctx
+func (_m *MockLNClient) GetOnchainBalance(ctx context.Context) (*lnclient.OnchainBalanceResponse, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetOnchainBalance")
+	}
+
+	var r0 *lnclient.OnchainBalanceResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) (*lnclient.OnchainBalanceResponse, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) *lnclient.OnchainBalanceResponse); ok {
+		r0 = rf(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.OnchainBalanceResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetOnchainBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOnchainBalance'
+type MockLNClient_GetOnchainBalance_Call struct {
+	*mock.Call
+}
+
+// GetOnchainBalance is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockLNClient_Expecter) GetOnchainBalance(ctx interface{}) *MockLNClient_GetOnchainBalance_Call {
+	return &MockLNClient_GetOnchainBalance_Call{Call: _e.mock.On("GetOnchainBalance", ctx)}
+}
+
+func (_c *MockLNClient_GetOnchainBalance_Call) Run(run func(ctx context.Context)) *MockLNClient_GetOnchainBalance_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetOnchainBalance_Call) Return(_a0 *lnclient.OnchainBalanceResponse, _a1 error) *MockLNClient_GetOnchainBalance_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_GetOnchainBalance_Call) RunAndReturn(run func(context.Context) (*lnclient.OnchainBalanceResponse, error)) *MockLNClient_GetOnchainBalance_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPubkey provides a mock function with no fields
+func (_m *MockLNClient) GetPubkey() string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPubkey")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockLNClient_GetPubkey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPubkey'
+type MockLNClient_GetPubkey_Call struct {
+	*mock.Call
+}
+
+// GetPubkey is a helper method to define mock.On call
+func (_e *MockLNClient_Expecter) GetPubkey() *MockLNClient_GetPubkey_Call {
+	return &MockLNClient_GetPubkey_Call{Call: _e.mock.On("GetPubkey")}
+}
+
+func (_c *MockLNClient_GetPubkey_Call) Run(run func()) *MockLNClient_GetPubkey_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetPubkey_Call) Return(_a0 string) *MockLNClient_GetPubkey_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_GetPubkey_Call) RunAndReturn(run func() string) *MockLNClient_GetPubkey_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetStorageDir provides a mock function with no fields
+func (_m *MockLNClient) GetStorageDir() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetStorageDir")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_GetStorageDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStorageDir'
+type MockLNClient_GetStorageDir_Call struct {
+	*mock.Call
+}
+
+// GetStorageDir is a helper method to define mock.On call
+func (_e *MockLNClient_Expecter) GetStorageDir() *MockLNClient_GetStorageDir_Call {
+	return &MockLNClient_GetStorageDir_Call{Call: _e.mock.On("GetStorageDir")}
+}
+
+func (_c *MockLNClient_GetStorageDir_Call) Run(run func()) *MockLNClient_GetStorageDir_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetStorageDir_Call) Return(_a0 string, _a1 error) *MockLNClient_GetStorageDir_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_GetStorageDir_Call) RunAndReturn(run func() (string, error)) *MockLNClient_GetStorageDir_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetSupportedNIP47Methods provides a mock function with no fields
+func (_m *MockLNClient) GetSupportedNIP47Methods() []string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSupportedNIP47Methods")
+	}
+
+	var r0 []string
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	return r0
+}
+
+// MockLNClient_GetSupportedNIP47Methods_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSupportedNIP47Methods'
+type MockLNClient_GetSupportedNIP47Methods_Call struct {
+	*mock.Call
+}
+
+// GetSupportedNIP47Methods is a helper method to define mock.On call
+func (_e *MockLNClient_Expecter) GetSupportedNIP47Methods() *MockLNClient_GetSupportedNIP47Methods_Call {
+	return &MockLNClient_GetSupportedNIP47Methods_Call{Call: _e.mock.On("GetSupportedNIP47Methods")}
+}
+
+func (_c *MockLNClient_GetSupportedNIP47Methods_Call) Run(run func()) *MockLNClient_GetSupportedNIP47Methods_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetSupportedNIP47Methods_Call) Return(_a0 []string) *MockLNClient_GetSupportedNIP47Methods_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_GetSupportedNIP47Methods_Call) RunAndReturn(run func() []string) *MockLNClient_GetSupportedNIP47Methods_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetSupportedNIP47NotificationTypes provides a mock function with no fields
+func (_m *MockLNClient) GetSupportedNIP47NotificationTypes() []string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSupportedNIP47NotificationTypes")
+	}
+
+	var r0 []string
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	return r0
+}
+
+// MockLNClient_GetSupportedNIP47NotificationTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSupportedNIP47NotificationTypes'
+type MockLNClient_GetSupportedNIP47NotificationTypes_Call struct {
+	*mock.Call
+}
+
+// GetSupportedNIP47NotificationTypes is a helper method to define mock.On call
+func (_e *MockLNClient_Expecter) GetSupportedNIP47NotificationTypes() *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
+	return &MockLNClient_GetSupportedNIP47NotificationTypes_Call{Call: _e.mock.On("GetSupportedNIP47NotificationTypes")}
+}
+
+func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) Run(run func()) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) Return(_a0 []string) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) RunAndReturn(run func() []string) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ListChannels provides a mock function with given fields: ctx
+func (_m *MockLNClient) ListChannels(ctx context.Context) ([]lnclient.Channel, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ListChannels")
+	}
+
+	var r0 []lnclient.Channel
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) ([]lnclient.Channel, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) []lnclient.Channel); ok {
+		r0 = rf(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]lnclient.Channel)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_ListChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannels'
+type MockLNClient_ListChannels_Call struct {
+	*mock.Call
+}
+
+// ListChannels is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockLNClient_Expecter) ListChannels(ctx interface{}) *MockLNClient_ListChannels_Call {
+	return &MockLNClient_ListChannels_Call{Call: _e.mock.On("ListChannels", ctx)}
+}
+
+func (_c *MockLNClient_ListChannels_Call) Run(run func(ctx context.Context)) *MockLNClient_ListChannels_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_ListChannels_Call) Return(channels []lnclient.Channel, err error) *MockLNClient_ListChannels_Call {
+	_c.Call.Return(channels, err)
+	return _c
+}
+
+func (_c *MockLNClient_ListChannels_Call) RunAndReturn(run func(context.Context) ([]lnclient.Channel, error)) *MockLNClient_ListChannels_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ListPeers provides a mock function with given fields: ctx
+func (_m *MockLNClient) ListPeers(ctx context.Context) ([]lnclient.PeerDetails, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ListPeers")
+	}
+
+	var r0 []lnclient.PeerDetails
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) ([]lnclient.PeerDetails, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) []lnclient.PeerDetails); ok {
+		r0 = rf(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]lnclient.PeerDetails)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_ListPeers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeers'
+type MockLNClient_ListPeers_Call struct {
+	*mock.Call
+}
+
+// ListPeers is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockLNClient_Expecter) ListPeers(ctx interface{}) *MockLNClient_ListPeers_Call {
+	return &MockLNClient_ListPeers_Call{Call: _e.mock.On("ListPeers", ctx)}
+}
+
+func (_c *MockLNClient_ListPeers_Call) Run(run func(ctx context.Context)) *MockLNClient_ListPeers_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_ListPeers_Call) Return(_a0 []lnclient.PeerDetails, _a1 error) *MockLNClient_ListPeers_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_ListPeers_Call) RunAndReturn(run func(context.Context) ([]lnclient.PeerDetails, error)) *MockLNClient_ListPeers_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ListTransactions provides a mock function with given fields: ctx, from, until, limit, offset, unpaid, invoiceType
+func (_m *MockLNClient) ListTransactions(ctx context.Context, from uint64, until uint64, limit uint64, offset uint64, unpaid bool, invoiceType string) ([]lnclient.Transaction, error) {
+	ret := _m.Called(ctx, from, until, limit, offset, unpaid, invoiceType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ListTransactions")
+	}
+
+	var r0 []lnclient.Transaction
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, uint64, uint64, uint64, uint64, bool, string) ([]lnclient.Transaction, error)); ok {
+		return rf(ctx, from, until, limit, offset, unpaid, invoiceType)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, uint64, uint64, uint64, uint64, bool, string) []lnclient.Transaction); ok {
+		r0 = rf(ctx, from, until, limit, offset, unpaid, invoiceType)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]lnclient.Transaction)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, uint64, uint64, uint64, uint64, bool, string) error); ok {
+		r1 = rf(ctx, from, until, limit, offset, unpaid, invoiceType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_ListTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTransactions'
+type MockLNClient_ListTransactions_Call struct {
+	*mock.Call
+}
+
+// ListTransactions is a helper method to define mock.On call
+//   - ctx context.Context
+//   - from uint64
+//   - until uint64
+//   - limit uint64
+//   - offset uint64
+//   - unpaid bool
+//   - invoiceType string
+func (_e *MockLNClient_Expecter) ListTransactions(ctx interface{}, from interface{}, until interface{}, limit interface{}, offset interface{}, unpaid interface{}, invoiceType interface{}) *MockLNClient_ListTransactions_Call {
+	return &MockLNClient_ListTransactions_Call{Call: _e.mock.On("ListTransactions", ctx, from, until, limit, offset, unpaid, invoiceType)}
+}
+
+func (_c *MockLNClient_ListTransactions_Call) Run(run func(ctx context.Context, from uint64, until uint64, limit uint64, offset uint64, unpaid bool, invoiceType string)) *MockLNClient_ListTransactions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64), args[2].(uint64), args[3].(uint64), args[4].(uint64), args[5].(bool), args[6].(string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_ListTransactions_Call) Return(transactions []lnclient.Transaction, err error) *MockLNClient_ListTransactions_Call {
+	_c.Call.Return(transactions, err)
+	return _c
+}
+
+func (_c *MockLNClient_ListTransactions_Call) RunAndReturn(run func(context.Context, uint64, uint64, uint64, uint64, bool, string) ([]lnclient.Transaction, error)) *MockLNClient_ListTransactions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// LookupInvoice provides a mock function with given fields: ctx, paymentHash
+func (_m *MockLNClient) LookupInvoice(ctx context.Context, paymentHash string) (*lnclient.Transaction, error) {
+	ret := _m.Called(ctx, paymentHash)
+
+	if len(ret) == 0 {
+		panic("no return value specified for LookupInvoice")
+	}
+
+	var r0 *lnclient.Transaction
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string) (*lnclient.Transaction, error)); ok {
+		return rf(ctx, paymentHash)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string) *lnclient.Transaction); ok {
+		r0 = rf(ctx, paymentHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.Transaction)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
+		r1 = rf(ctx, paymentHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_LookupInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LookupInvoice'
+type MockLNClient_LookupInvoice_Call struct {
+	*mock.Call
+}
+
+// LookupInvoice is a helper method to define mock.On call
+//   - ctx context.Context
+//   - paymentHash string
+func (_e *MockLNClient_Expecter) LookupInvoice(ctx interface{}, paymentHash interface{}) *MockLNClient_LookupInvoice_Call {
+	return &MockLNClient_LookupInvoice_Call{Call: _e.mock.On("LookupInvoice", ctx, paymentHash)}
+}
+
+func (_c *MockLNClient_LookupInvoice_Call) Run(run func(ctx context.Context, paymentHash string)) *MockLNClient_LookupInvoice_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_LookupInvoice_Call) Return(transaction *lnclient.Transaction, err error) *MockLNClient_LookupInvoice_Call {
+	_c.Call.Return(transaction, err)
+	return _c
+}
+
+func (_c *MockLNClient_LookupInvoice_Call) RunAndReturn(run func(context.Context, string) (*lnclient.Transaction, error)) *MockLNClient_LookupInvoice_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MakeInvoice provides a mock function with given fields: ctx, amount, description, descriptionHash, expiry
+func (_m *MockLNClient) MakeInvoice(ctx context.Context, amount int64, description string, descriptionHash string, expiry int64) (*lnclient.Transaction, error) {
+	ret := _m.Called(ctx, amount, description, descriptionHash, expiry)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MakeInvoice")
+	}
+
+	var r0 *lnclient.Transaction
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, int64, string, string, int64) (*lnclient.Transaction, error)); ok {
+		return rf(ctx, amount, description, descriptionHash, expiry)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, int64, string, string, int64) *lnclient.Transaction); ok {
+		r0 = rf(ctx, amount, description, descriptionHash, expiry)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.Transaction)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, int64, string, string, int64) error); ok {
+		r1 = rf(ctx, amount, description, descriptionHash, expiry)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_MakeInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MakeInvoice'
+type MockLNClient_MakeInvoice_Call struct {
+	*mock.Call
+}
+
+// MakeInvoice is a helper method to define mock.On call
+//   - ctx context.Context
+//   - amount int64
+//   - description string
+//   - descriptionHash string
+//   - expiry int64
+func (_e *MockLNClient_Expecter) MakeInvoice(ctx interface{}, amount interface{}, description interface{}, descriptionHash interface{}, expiry interface{}) *MockLNClient_MakeInvoice_Call {
+	return &MockLNClient_MakeInvoice_Call{Call: _e.mock.On("MakeInvoice", ctx, amount, description, descriptionHash, expiry)}
+}
+
+func (_c *MockLNClient_MakeInvoice_Call) Run(run func(ctx context.Context, amount int64, description string, descriptionHash string, expiry int64)) *MockLNClient_MakeInvoice_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(string), args[4].(int64))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_MakeInvoice_Call) Return(transaction *lnclient.Transaction, err error) *MockLNClient_MakeInvoice_Call {
+	_c.Call.Return(transaction, err)
+	return _c
+}
+
+func (_c *MockLNClient_MakeInvoice_Call) RunAndReturn(run func(context.Context, int64, string, string, int64) (*lnclient.Transaction, error)) *MockLNClient_MakeInvoice_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OpenChannel provides a mock function with given fields: ctx, openChannelRequest
+func (_m *MockLNClient) OpenChannel(ctx context.Context, openChannelRequest *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error) {
+	ret := _m.Called(ctx, openChannelRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OpenChannel")
+	}
+
+	var r0 *lnclient.OpenChannelResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error)); ok {
+		return rf(ctx, openChannelRequest)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *lnclient.OpenChannelRequest) *lnclient.OpenChannelResponse); ok {
+		r0 = rf(ctx, openChannelRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.OpenChannelResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *lnclient.OpenChannelRequest) error); ok {
+		r1 = rf(ctx, openChannelRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_OpenChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenChannel'
+type MockLNClient_OpenChannel_Call struct {
+	*mock.Call
+}
+
+// OpenChannel is a helper method to define mock.On call
+//   - ctx context.Context
+//   - openChannelRequest *lnclient.OpenChannelRequest
+func (_e *MockLNClient_Expecter) OpenChannel(ctx interface{}, openChannelRequest interface{}) *MockLNClient_OpenChannel_Call {
+	return &MockLNClient_OpenChannel_Call{Call: _e.mock.On("OpenChannel", ctx, openChannelRequest)}
+}
+
+func (_c *MockLNClient_OpenChannel_Call) Run(run func(ctx context.Context, openChannelRequest *lnclient.OpenChannelRequest)) *MockLNClient_OpenChannel_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*lnclient.OpenChannelRequest))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_OpenChannel_Call) Return(_a0 *lnclient.OpenChannelResponse, _a1 error) *MockLNClient_OpenChannel_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_OpenChannel_Call) RunAndReturn(run func(context.Context, *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error)) *MockLNClient_OpenChannel_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RedeemOnchainFunds provides a mock function with given fields: ctx, toAddress, amount, sendAll
+func (_m *MockLNClient) RedeemOnchainFunds(ctx context.Context, toAddress string, amount uint64, sendAll bool) (string, error) {
+	ret := _m.Called(ctx, toAddress, amount, sendAll)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RedeemOnchainFunds")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, uint64, bool) (string, error)); ok {
+		return rf(ctx, toAddress, amount, sendAll)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, uint64, bool) string); ok {
+		r0 = rf(ctx, toAddress, amount, sendAll)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, uint64, bool) error); ok {
+		r1 = rf(ctx, toAddress, amount, sendAll)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_RedeemOnchainFunds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RedeemOnchainFunds'
+type MockLNClient_RedeemOnchainFunds_Call struct {
+	*mock.Call
+}
+
+// RedeemOnchainFunds is a helper method to define mock.On call
+//   - ctx context.Context
+//   - toAddress string
+//   - amount uint64
+//   - sendAll bool
+func (_e *MockLNClient_Expecter) RedeemOnchainFunds(ctx interface{}, toAddress interface{}, amount interface{}, sendAll interface{}) *MockLNClient_RedeemOnchainFunds_Call {
+	return &MockLNClient_RedeemOnchainFunds_Call{Call: _e.mock.On("RedeemOnchainFunds", ctx, toAddress, amount, sendAll)}
+}
+
+func (_c *MockLNClient_RedeemOnchainFunds_Call) Run(run func(ctx context.Context, toAddress string, amount uint64, sendAll bool)) *MockLNClient_RedeemOnchainFunds_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(uint64), args[3].(bool))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_RedeemOnchainFunds_Call) Return(txId string, err error) *MockLNClient_RedeemOnchainFunds_Call {
+	_c.Call.Return(txId, err)
+	return _c
+}
+
+func (_c *MockLNClient_RedeemOnchainFunds_Call) RunAndReturn(run func(context.Context, string, uint64, bool) (string, error)) *MockLNClient_RedeemOnchainFunds_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ResetRouter provides a mock function with given fields: key
+func (_m *MockLNClient) ResetRouter(key string) error {
+	ret := _m.Called(key)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ResetRouter")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(key)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockLNClient_ResetRouter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetRouter'
+type MockLNClient_ResetRouter_Call struct {
+	*mock.Call
+}
+
+// ResetRouter is a helper method to define mock.On call
+//   - key string
+func (_e *MockLNClient_Expecter) ResetRouter(key interface{}) *MockLNClient_ResetRouter_Call {
+	return &MockLNClient_ResetRouter_Call{Call: _e.mock.On("ResetRouter", key)}
+}
+
+func (_c *MockLNClient_ResetRouter_Call) Run(run func(key string)) *MockLNClient_ResetRouter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_ResetRouter_Call) Return(_a0 error) *MockLNClient_ResetRouter_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_ResetRouter_Call) RunAndReturn(run func(string) error) *MockLNClient_ResetRouter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendKeysend provides a mock function with given fields: ctx, amount, destination, customRecords, preimage
+func (_m *MockLNClient) SendKeysend(ctx context.Context, amount uint64, destination string, customRecords []lnclient.TLVRecord, preimage string) (*lnclient.PayKeysendResponse, error) {
+	ret := _m.Called(ctx, amount, destination, customRecords, preimage)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendKeysend")
+	}
+
+	var r0 *lnclient.PayKeysendResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, uint64, string, []lnclient.TLVRecord, string) (*lnclient.PayKeysendResponse, error)); ok {
+		return rf(ctx, amount, destination, customRecords, preimage)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, uint64, string, []lnclient.TLVRecord, string) *lnclient.PayKeysendResponse); ok {
+		r0 = rf(ctx, amount, destination, customRecords, preimage)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.PayKeysendResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, uint64, string, []lnclient.TLVRecord, string) error); ok {
+		r1 = rf(ctx, amount, destination, customRecords, preimage)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_SendKeysend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendKeysend'
+type MockLNClient_SendKeysend_Call struct {
+	*mock.Call
+}
+
+// SendKeysend is a helper method to define mock.On call
+//   - ctx context.Context
+//   - amount uint64
+//   - destination string
+//   - customRecords []lnclient.TLVRecord
+//   - preimage string
+func (_e *MockLNClient_Expecter) SendKeysend(ctx interface{}, amount interface{}, destination interface{}, customRecords interface{}, preimage interface{}) *MockLNClient_SendKeysend_Call {
+	return &MockLNClient_SendKeysend_Call{Call: _e.mock.On("SendKeysend", ctx, amount, destination, customRecords, preimage)}
+}
+
+func (_c *MockLNClient_SendKeysend_Call) Run(run func(ctx context.Context, amount uint64, destination string, customRecords []lnclient.TLVRecord, preimage string)) *MockLNClient_SendKeysend_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64), args[2].(string), args[3].([]lnclient.TLVRecord), args[4].(string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_SendKeysend_Call) Return(_a0 *lnclient.PayKeysendResponse, _a1 error) *MockLNClient_SendKeysend_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_SendKeysend_Call) RunAndReturn(run func(context.Context, uint64, string, []lnclient.TLVRecord, string) (*lnclient.PayKeysendResponse, error)) *MockLNClient_SendKeysend_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendPaymentProbes provides a mock function with given fields: ctx, invoice
+func (_m *MockLNClient) SendPaymentProbes(ctx context.Context, invoice string) error {
+	ret := _m.Called(ctx, invoice)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendPaymentProbes")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
+		r0 = rf(ctx, invoice)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockLNClient_SendPaymentProbes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendPaymentProbes'
+type MockLNClient_SendPaymentProbes_Call struct {
+	*mock.Call
+}
+
+// SendPaymentProbes is a helper method to define mock.On call
+//   - ctx context.Context
+//   - invoice string
+func (_e *MockLNClient_Expecter) SendPaymentProbes(ctx interface{}, invoice interface{}) *MockLNClient_SendPaymentProbes_Call {
+	return &MockLNClient_SendPaymentProbes_Call{Call: _e.mock.On("SendPaymentProbes", ctx, invoice)}
+}
+
+func (_c *MockLNClient_SendPaymentProbes_Call) Run(run func(ctx context.Context, invoice string)) *MockLNClient_SendPaymentProbes_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_SendPaymentProbes_Call) Return(_a0 error) *MockLNClient_SendPaymentProbes_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_SendPaymentProbes_Call) RunAndReturn(run func(context.Context, string) error) *MockLNClient_SendPaymentProbes_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendPaymentSync provides a mock function with given fields: ctx, payReq, amount
+func (_m *MockLNClient) SendPaymentSync(ctx context.Context, payReq string, amount *uint64) (*lnclient.PayInvoiceResponse, error) {
+	ret := _m.Called(ctx, payReq, amount)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendPaymentSync")
+	}
+
+	var r0 *lnclient.PayInvoiceResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, *uint64) (*lnclient.PayInvoiceResponse, error)); ok {
+		return rf(ctx, payReq, amount)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, *uint64) *lnclient.PayInvoiceResponse); ok {
+		r0 = rf(ctx, payReq, amount)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*lnclient.PayInvoiceResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, *uint64) error); ok {
+		r1 = rf(ctx, payReq, amount)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_SendPaymentSync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendPaymentSync'
+type MockLNClient_SendPaymentSync_Call struct {
+	*mock.Call
+}
+
+// SendPaymentSync is a helper method to define mock.On call
+//   - ctx context.Context
+//   - payReq string
+//   - amount *uint64
+func (_e *MockLNClient_Expecter) SendPaymentSync(ctx interface{}, payReq interface{}, amount interface{}) *MockLNClient_SendPaymentSync_Call {
+	return &MockLNClient_SendPaymentSync_Call{Call: _e.mock.On("SendPaymentSync", ctx, payReq, amount)}
+}
+
+func (_c *MockLNClient_SendPaymentSync_Call) Run(run func(ctx context.Context, payReq string, amount *uint64)) *MockLNClient_SendPaymentSync_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(*uint64))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_SendPaymentSync_Call) Return(_a0 *lnclient.PayInvoiceResponse, _a1 error) *MockLNClient_SendPaymentSync_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_SendPaymentSync_Call) RunAndReturn(run func(context.Context, string, *uint64) (*lnclient.PayInvoiceResponse, error)) *MockLNClient_SendPaymentSync_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendSpontaneousPaymentProbes provides a mock function with given fields: ctx, amountMsat, nodeId
+func (_m *MockLNClient) SendSpontaneousPaymentProbes(ctx context.Context, amountMsat uint64, nodeId string) error {
+	ret := _m.Called(ctx, amountMsat, nodeId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendSpontaneousPaymentProbes")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, uint64, string) error); ok {
+		r0 = rf(ctx, amountMsat, nodeId)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockLNClient_SendSpontaneousPaymentProbes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendSpontaneousPaymentProbes'
+type MockLNClient_SendSpontaneousPaymentProbes_Call struct {
+	*mock.Call
+}
+
+// SendSpontaneousPaymentProbes is a helper method to define mock.On call
+//   - ctx context.Context
+//   - amountMsat uint64
+//   - nodeId string
+func (_e *MockLNClient_Expecter) SendSpontaneousPaymentProbes(ctx interface{}, amountMsat interface{}, nodeId interface{}) *MockLNClient_SendSpontaneousPaymentProbes_Call {
+	return &MockLNClient_SendSpontaneousPaymentProbes_Call{Call: _e.mock.On("SendSpontaneousPaymentProbes", ctx, amountMsat, nodeId)}
+}
+
+func (_c *MockLNClient_SendSpontaneousPaymentProbes_Call) Run(run func(ctx context.Context, amountMsat uint64, nodeId string)) *MockLNClient_SendSpontaneousPaymentProbes_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64), args[2].(string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_SendSpontaneousPaymentProbes_Call) Return(_a0 error) *MockLNClient_SendSpontaneousPaymentProbes_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_SendSpontaneousPaymentProbes_Call) RunAndReturn(run func(context.Context, uint64, string) error) *MockLNClient_SendSpontaneousPaymentProbes_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Shutdown provides a mock function with no fields
+func (_m *MockLNClient) Shutdown() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Shutdown")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockLNClient_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'
+type MockLNClient_Shutdown_Call struct {
+	*mock.Call
+}
+
+// Shutdown is a helper method to define mock.On call
+func (_e *MockLNClient_Expecter) Shutdown() *MockLNClient_Shutdown_Call {
+	return &MockLNClient_Shutdown_Call{Call: _e.mock.On("Shutdown")}
+}
+
+func (_c *MockLNClient_Shutdown_Call) Run(run func()) *MockLNClient_Shutdown_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockLNClient_Shutdown_Call) Return(_a0 error) *MockLNClient_Shutdown_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_Shutdown_Call) RunAndReturn(run func() error) *MockLNClient_Shutdown_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SignMessage provides a mock function with given fields: ctx, message
+func (_m *MockLNClient) SignMessage(ctx context.Context, message string) (string, error) {
+	ret := _m.Called(ctx, message)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SignMessage")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
+		return rf(ctx, message)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string) string); ok {
+		r0 = rf(ctx, message)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
+		r1 = rf(ctx, message)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockLNClient_SignMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignMessage'
+type MockLNClient_SignMessage_Call struct {
+	*mock.Call
+}
+
+// SignMessage is a helper method to define mock.On call
+//   - ctx context.Context
+//   - message string
+func (_e *MockLNClient_Expecter) SignMessage(ctx interface{}, message interface{}) *MockLNClient_SignMessage_Call {
+	return &MockLNClient_SignMessage_Call{Call: _e.mock.On("SignMessage", ctx, message)}
+}
+
+func (_c *MockLNClient_SignMessage_Call) Run(run func(ctx context.Context, message string)) *MockLNClient_SignMessage_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_SignMessage_Call) Return(_a0 string, _a1 error) *MockLNClient_SignMessage_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockLNClient_SignMessage_Call) RunAndReturn(run func(context.Context, string) (string, error)) *MockLNClient_SignMessage_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UpdateChannel provides a mock function with given fields: ctx, updateChannelRequest
+func (_m *MockLNClient) UpdateChannel(ctx context.Context, updateChannelRequest *lnclient.UpdateChannelRequest) error {
+	ret := _m.Called(ctx, updateChannelRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateChannel")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, *lnclient.UpdateChannelRequest) error); ok {
+		r0 = rf(ctx, updateChannelRequest)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockLNClient_UpdateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannel'
+type MockLNClient_UpdateChannel_Call struct {
+	*mock.Call
+}
+
+// UpdateChannel is a helper method to define mock.On call
+//   - ctx context.Context
+//   - updateChannelRequest *lnclient.UpdateChannelRequest
+func (_e *MockLNClient_Expecter) UpdateChannel(ctx interface{}, updateChannelRequest interface{}) *MockLNClient_UpdateChannel_Call {
+	return &MockLNClient_UpdateChannel_Call{Call: _e.mock.On("UpdateChannel", ctx, updateChannelRequest)}
+}
+
+func (_c *MockLNClient_UpdateChannel_Call) Run(run func(ctx context.Context, updateChannelRequest *lnclient.UpdateChannelRequest)) *MockLNClient_UpdateChannel_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*lnclient.UpdateChannelRequest))
+	})
+	return _c
+}
+
+func (_c *MockLNClient_UpdateChannel_Call) Return(_a0 error) *MockLNClient_UpdateChannel_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockLNClient_UpdateChannel_Call) RunAndReturn(run func(context.Context, *lnclient.UpdateChannelRequest) error) *MockLNClient_UpdateChannel_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UpdateLastWalletSyncRequest provides a mock function with no fields
+func (_m *MockLNClient) UpdateLastWalletSyncRequest() {
+	_m.Called()
+}
+
+// MockLNClient_UpdateLastWalletSyncRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLastWalletSyncRequest'
+type MockLNClient_UpdateLastWalletSyncRequest_Call struct {
+	*mock.Call
+}
+
+// UpdateLastWalletSyncRequest is a helper method to define mock.On call
+func (_e *MockLNClient_Expecter) UpdateLastWalletSyncRequest() *MockLNClient_UpdateLastWalletSyncRequest_Call {
+	return &MockLNClient_UpdateLastWalletSyncRequest_Call{Call: _e.mock.On("UpdateLastWalletSyncRequest")}
+}
+
+func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) Run(run func()) *MockLNClient_UpdateLastWalletSyncRequest_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) Return() *MockLNClient_UpdateLastWalletSyncRequest_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) RunAndReturn(run func()) *MockLNClient_UpdateLastWalletSyncRequest_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewMockLNClient creates a new instance of MockLNClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockLNClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockLNClient {
+	mock := &MockLNClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/tests/mocks/Service.go b/tests/mocks/Service.go
new file mode 100644
index 000000000..b5363f1ff
--- /dev/null
+++ b/tests/mocks/Service.go
@@ -0,0 +1,531 @@
+// Code generated by mockery v2.51.1. DO NOT EDIT.
+
+package mocks
+
+import (
+	alby "github.com/getAlby/hub/alby"
+	config "github.com/getAlby/hub/config"
+
+	events "github.com/getAlby/hub/events"
+
+	gorm "gorm.io/gorm"
+
+	keys "github.com/getAlby/hub/service/keys"
+
+	lnclient "github.com/getAlby/hub/lnclient"
+
+	mock "github.com/stretchr/testify/mock"
+
+	transactions "github.com/getAlby/hub/transactions"
+)
+
+// MockService is an autogenerated mock type for the Service type
+type MockService struct {
+	mock.Mock
+}
+
+type MockService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockService) EXPECT() *MockService_Expecter {
+	return &MockService_Expecter{mock: &_m.Mock}
+}
+
+// GetAlbyOAuthSvc provides a mock function with no fields
+func (_m *MockService) GetAlbyOAuthSvc() alby.AlbyOAuthService {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAlbyOAuthSvc")
+	}
+
+	var r0 alby.AlbyOAuthService
+	if rf, ok := ret.Get(0).(func() alby.AlbyOAuthService); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(alby.AlbyOAuthService)
+		}
+	}
+
+	return r0
+}
+
+// MockService_GetAlbyOAuthSvc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlbyOAuthSvc'
+type MockService_GetAlbyOAuthSvc_Call struct {
+	*mock.Call
+}
+
+// GetAlbyOAuthSvc is a helper method to define mock.On call
+func (_e *MockService_Expecter) GetAlbyOAuthSvc() *MockService_GetAlbyOAuthSvc_Call {
+	return &MockService_GetAlbyOAuthSvc_Call{Call: _e.mock.On("GetAlbyOAuthSvc")}
+}
+
+func (_c *MockService_GetAlbyOAuthSvc_Call) Run(run func()) *MockService_GetAlbyOAuthSvc_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_GetAlbyOAuthSvc_Call) Return(_a0 alby.AlbyOAuthService) *MockService_GetAlbyOAuthSvc_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_GetAlbyOAuthSvc_Call) RunAndReturn(run func() alby.AlbyOAuthService) *MockService_GetAlbyOAuthSvc_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetConfig provides a mock function with no fields
+func (_m *MockService) GetConfig() config.Config {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetConfig")
+	}
+
+	var r0 config.Config
+	if rf, ok := ret.Get(0).(func() config.Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(config.Config)
+		}
+	}
+
+	return r0
+}
+
+// MockService_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig'
+type MockService_GetConfig_Call struct {
+	*mock.Call
+}
+
+// GetConfig is a helper method to define mock.On call
+func (_e *MockService_Expecter) GetConfig() *MockService_GetConfig_Call {
+	return &MockService_GetConfig_Call{Call: _e.mock.On("GetConfig")}
+}
+
+func (_c *MockService_GetConfig_Call) Run(run func()) *MockService_GetConfig_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_GetConfig_Call) Return(_a0 config.Config) *MockService_GetConfig_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_GetConfig_Call) RunAndReturn(run func() config.Config) *MockService_GetConfig_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetDB provides a mock function with no fields
+func (_m *MockService) GetDB() *gorm.DB {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDB")
+	}
+
+	var r0 *gorm.DB
+	if rf, ok := ret.Get(0).(func() *gorm.DB); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*gorm.DB)
+		}
+	}
+
+	return r0
+}
+
+// MockService_GetDB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDB'
+type MockService_GetDB_Call struct {
+	*mock.Call
+}
+
+// GetDB is a helper method to define mock.On call
+func (_e *MockService_Expecter) GetDB() *MockService_GetDB_Call {
+	return &MockService_GetDB_Call{Call: _e.mock.On("GetDB")}
+}
+
+func (_c *MockService_GetDB_Call) Run(run func()) *MockService_GetDB_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_GetDB_Call) Return(_a0 *gorm.DB) *MockService_GetDB_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_GetDB_Call) RunAndReturn(run func() *gorm.DB) *MockService_GetDB_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetEventPublisher provides a mock function with no fields
+func (_m *MockService) GetEventPublisher() events.EventPublisher {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetEventPublisher")
+	}
+
+	var r0 events.EventPublisher
+	if rf, ok := ret.Get(0).(func() events.EventPublisher); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(events.EventPublisher)
+		}
+	}
+
+	return r0
+}
+
+// MockService_GetEventPublisher_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEventPublisher'
+type MockService_GetEventPublisher_Call struct {
+	*mock.Call
+}
+
+// GetEventPublisher is a helper method to define mock.On call
+func (_e *MockService_Expecter) GetEventPublisher() *MockService_GetEventPublisher_Call {
+	return &MockService_GetEventPublisher_Call{Call: _e.mock.On("GetEventPublisher")}
+}
+
+func (_c *MockService_GetEventPublisher_Call) Run(run func()) *MockService_GetEventPublisher_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_GetEventPublisher_Call) Return(_a0 events.EventPublisher) *MockService_GetEventPublisher_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_GetEventPublisher_Call) RunAndReturn(run func() events.EventPublisher) *MockService_GetEventPublisher_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetKeys provides a mock function with no fields
+func (_m *MockService) GetKeys() keys.Keys {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetKeys")
+	}
+
+	var r0 keys.Keys
+	if rf, ok := ret.Get(0).(func() keys.Keys); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(keys.Keys)
+		}
+	}
+
+	return r0
+}
+
+// MockService_GetKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeys'
+type MockService_GetKeys_Call struct {
+	*mock.Call
+}
+
+// GetKeys is a helper method to define mock.On call
+func (_e *MockService_Expecter) GetKeys() *MockService_GetKeys_Call {
+	return &MockService_GetKeys_Call{Call: _e.mock.On("GetKeys")}
+}
+
+func (_c *MockService_GetKeys_Call) Run(run func()) *MockService_GetKeys_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_GetKeys_Call) Return(_a0 keys.Keys) *MockService_GetKeys_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_GetKeys_Call) RunAndReturn(run func() keys.Keys) *MockService_GetKeys_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetLNClient provides a mock function with no fields
+func (_m *MockService) GetLNClient() lnclient.LNClient {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLNClient")
+	}
+
+	var r0 lnclient.LNClient
+	if rf, ok := ret.Get(0).(func() lnclient.LNClient); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(lnclient.LNClient)
+		}
+	}
+
+	return r0
+}
+
+// MockService_GetLNClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLNClient'
+type MockService_GetLNClient_Call struct {
+	*mock.Call
+}
+
+// GetLNClient is a helper method to define mock.On call
+func (_e *MockService_Expecter) GetLNClient() *MockService_GetLNClient_Call {
+	return &MockService_GetLNClient_Call{Call: _e.mock.On("GetLNClient")}
+}
+
+func (_c *MockService_GetLNClient_Call) Run(run func()) *MockService_GetLNClient_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_GetLNClient_Call) Return(_a0 lnclient.LNClient) *MockService_GetLNClient_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_GetLNClient_Call) RunAndReturn(run func() lnclient.LNClient) *MockService_GetLNClient_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetTransactionsService provides a mock function with no fields
+func (_m *MockService) GetTransactionsService() transactions.TransactionsService {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetTransactionsService")
+	}
+
+	var r0 transactions.TransactionsService
+	if rf, ok := ret.Get(0).(func() transactions.TransactionsService); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(transactions.TransactionsService)
+		}
+	}
+
+	return r0
+}
+
+// MockService_GetTransactionsService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransactionsService'
+type MockService_GetTransactionsService_Call struct {
+	*mock.Call
+}
+
+// GetTransactionsService is a helper method to define mock.On call
+func (_e *MockService_Expecter) GetTransactionsService() *MockService_GetTransactionsService_Call {
+	return &MockService_GetTransactionsService_Call{Call: _e.mock.On("GetTransactionsService")}
+}
+
+func (_c *MockService_GetTransactionsService_Call) Run(run func()) *MockService_GetTransactionsService_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_GetTransactionsService_Call) Return(_a0 transactions.TransactionsService) *MockService_GetTransactionsService_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_GetTransactionsService_Call) RunAndReturn(run func() transactions.TransactionsService) *MockService_GetTransactionsService_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// IsRelayReady provides a mock function with no fields
+func (_m *MockService) IsRelayReady() bool {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsRelayReady")
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func() bool); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// MockService_IsRelayReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsRelayReady'
+type MockService_IsRelayReady_Call struct {
+	*mock.Call
+}
+
+// IsRelayReady is a helper method to define mock.On call
+func (_e *MockService_Expecter) IsRelayReady() *MockService_IsRelayReady_Call {
+	return &MockService_IsRelayReady_Call{Call: _e.mock.On("IsRelayReady")}
+}
+
+func (_c *MockService_IsRelayReady_Call) Run(run func()) *MockService_IsRelayReady_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_IsRelayReady_Call) Return(_a0 bool) *MockService_IsRelayReady_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_IsRelayReady_Call) RunAndReturn(run func() bool) *MockService_IsRelayReady_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Shutdown provides a mock function with no fields
+func (_m *MockService) Shutdown() {
+	_m.Called()
+}
+
+// MockService_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'
+type MockService_Shutdown_Call struct {
+	*mock.Call
+}
+
+// Shutdown is a helper method to define mock.On call
+func (_e *MockService_Expecter) Shutdown() *MockService_Shutdown_Call {
+	return &MockService_Shutdown_Call{Call: _e.mock.On("Shutdown")}
+}
+
+func (_c *MockService_Shutdown_Call) Run(run func()) *MockService_Shutdown_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_Shutdown_Call) Return() *MockService_Shutdown_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockService_Shutdown_Call) RunAndReturn(run func()) *MockService_Shutdown_Call {
+	_c.Run(run)
+	return _c
+}
+
+// StartApp provides a mock function with given fields: encryptionKey
+func (_m *MockService) StartApp(encryptionKey string) error {
+	ret := _m.Called(encryptionKey)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StartApp")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(encryptionKey)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockService_StartApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartApp'
+type MockService_StartApp_Call struct {
+	*mock.Call
+}
+
+// StartApp is a helper method to define mock.On call
+//   - encryptionKey string
+func (_e *MockService_Expecter) StartApp(encryptionKey interface{}) *MockService_StartApp_Call {
+	return &MockService_StartApp_Call{Call: _e.mock.On("StartApp", encryptionKey)}
+}
+
+func (_c *MockService_StartApp_Call) Run(run func(encryptionKey string)) *MockService_StartApp_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockService_StartApp_Call) Return(_a0 error) *MockService_StartApp_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockService_StartApp_Call) RunAndReturn(run func(string) error) *MockService_StartApp_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// StopApp provides a mock function with no fields
+func (_m *MockService) StopApp() {
+	_m.Called()
+}
+
+// MockService_StopApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopApp'
+type MockService_StopApp_Call struct {
+	*mock.Call
+}
+
+// StopApp is a helper method to define mock.On call
+func (_e *MockService_Expecter) StopApp() *MockService_StopApp_Call {
+	return &MockService_StopApp_Call{Call: _e.mock.On("StopApp")}
+}
+
+func (_c *MockService_StopApp_Call) Run(run func()) *MockService_StopApp_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockService_StopApp_Call) Return() *MockService_StopApp_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockService_StopApp_Call) RunAndReturn(run func()) *MockService_StopApp_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewMockService creates a new instance of MockService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockService {
+	mock := &MockService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/utils/utils.go b/utils/utils.go
index d25bffeed..7dd781dc6 100644
--- a/utils/utils.go
+++ b/utils/utils.go
@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"strings"
+	"unicode"
 )
 
 func ReadFileTail(filePath string, maxLen int) (data []byte, err error) {
@@ -55,3 +57,39 @@ func Filter[T any](s []T, f func(T) bool) []T {
 	}
 	return r
 }
+
+func ParseCommandLine(s string) ([]string, error) {
+	args := make([]string, 0)
+	var currentArg strings.Builder
+	inQuotes := false
+	escaped := false
+
+	for _, r := range s {
+		switch {
+		case escaped:
+			currentArg.WriteRune(r)
+			escaped = false
+		case r == '\\':
+			escaped = true
+		case r == '"':
+			inQuotes = !inQuotes
+		case unicode.IsSpace(r) && !inQuotes:
+			if currentArg.Len() > 0 {
+				args = append(args, currentArg.String())
+				currentArg.Reset()
+			}
+		default:
+			currentArg.WriteRune(r)
+		}
+	}
+
+	if escaped || inQuotes {
+		return nil, fmt.Errorf("unexpected end of string")
+	}
+
+	if currentArg.Len() > 0 {
+		args = append(args, currentArg.String())
+	}
+
+	return args, nil
+}
diff --git a/utils/utils_test.go b/utils/utils_test.go
new file mode 100644
index 000000000..50db58237
--- /dev/null
+++ b/utils/utils_test.go
@@ -0,0 +1,102 @@
+package utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseCommandLine(t *testing.T) {
+	t.Parallel()
+
+	type testCase struct {
+		name            string
+		input           string
+		expectedSuccess []string
+		expectedError   string
+	}
+
+	// When called by the API, the first argument of the command input is actually the command name
+	testCases := []testCase{
+		{
+			name:            "empty input",
+			input:           "",
+			expectedSuccess: []string{},
+			expectedError:   "",
+		},
+		{
+			name:            "single argument",
+			input:           "arg1",
+			expectedSuccess: []string{"arg1"},
+			expectedError:   "",
+		},
+		{
+			name:            "multiple arguments",
+			input:           "arg1 arg2 arg3",
+			expectedSuccess: []string{"arg1", "arg2", "arg3"},
+			expectedError:   "",
+		},
+		{
+			name:            "multiple arguments with extra whitespace",
+			input:           "  arg1\targ2   arg3  ",
+			expectedSuccess: []string{"arg1", "arg2", "arg3"},
+			expectedError:   "",
+		},
+		{
+			name:            "multiple arguments with quotes and escaping",
+			input:           `"arg 1" arg2 "arg\"3"`,
+			expectedSuccess: []string{"arg 1", "arg2", `arg"3`},
+			expectedError:   "",
+		},
+		{
+			name:            "unquoted escaped whitespace",
+			input:           `arg\ 1 arg2`,
+			expectedSuccess: []string{"arg 1", "arg2"},
+			expectedError:   "",
+		},
+		{
+			name:            "escaped JSON",
+			input:           `{\"hello\":\"world\"}`,
+			expectedSuccess: []string{`{"hello":"world"}`},
+			expectedError:   "",
+		},
+		{
+			name:            "escaped JSON with space",
+			input:           `"{\"hello\": \"world\"}"`,
+			expectedSuccess: []string{`{"hello": "world"}`},
+			expectedError:   "",
+		},
+		{
+			name:            "unclosed quote",
+			input:           `"arg 1", "arg2", "arg\"3`,
+			expectedSuccess: nil,
+			expectedError:   "unexpected end of string",
+		},
+		{
+			name:            "three quotes",
+			input:           `"""`,
+			expectedSuccess: nil,
+			expectedError:   "unexpected end of string",
+		},
+		{
+			name:            "unfinished escape",
+			input:           `arg\`,
+			expectedSuccess: nil,
+			expectedError:   "unexpected end of string",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			parsedArgs, err := ParseCommandLine(tc.input)
+			if tc.expectedError == "" {
+				assert.NoError(t, err)
+				assert.Equal(t, tc.expectedSuccess, parsedArgs)
+			} else {
+				assert.EqualError(t, err, tc.expectedError)
+				assert.Empty(t, parsedArgs)
+			}
+		})
+	}
+}
diff --git a/wails/wails_handlers.go b/wails/wails_handlers.go
index 5826ff0c9..cbc0d1bf3 100644
--- a/wails/wails_handlers.go
+++ b/wails/wails_handlers.go
@@ -921,6 +921,38 @@ func (app *WailsApp) WailsRequestRouter(route string, method string, body string
 			return WailsRequestRouterResponse{Body: nil, Error: err.Error()}
 		}
 		return WailsRequestRouterResponse{Body: *nodeHealth, Error: ""}
+	case "/api/commands":
+		nodeCommandsResponse, err := app.api.GetCustomNodeCommands()
+		if err != nil {
+			logger.Logger.WithFields(logrus.Fields{
+				"route":  route,
+				"method": method,
+				"body":   body,
+			}).WithError(err).Error("Failed to get node commands")
+			return WailsRequestRouterResponse{Body: nil, Error: err.Error()}
+		}
+		return WailsRequestRouterResponse{Body: nodeCommandsResponse, Error: ""}
+	case "/api/command":
+		commandRequest := &api.ExecuteCustomNodeCommandRequest{}
+		err := json.Unmarshal([]byte(body), commandRequest)
+		if err != nil {
+			logger.Logger.WithFields(logrus.Fields{
+				"route":  route,
+				"method": method,
+				"body":   body,
+			}).WithError(err).Error("Failed to decode request to wails router")
+			return WailsRequestRouterResponse{Body: nil, Error: err.Error()}
+		}
+		commandResponse, err := app.api.ExecuteCustomNodeCommand(ctx, commandRequest.Command)
+		if err != nil {
+			logger.Logger.WithFields(logrus.Fields{
+				"route":  route,
+				"method": method,
+				"body":   body,
+			}).WithError(err).Error("Failed to execute command")
+			return WailsRequestRouterResponse{Body: nil, Error: err.Error()}
+		}
+		return WailsRequestRouterResponse{Body: commandResponse, Error: ""}
 	}
 
 	if strings.HasPrefix(route, "/api/log/") {