diff --git a/proto/autogenerated/client.md b/proto/autogenerated/client.md
index 988fe113..65c78245 100644
--- a/proto/autogenerated/client.md
+++ b/proto/autogenerated/client.md
@@ -263,7 +263,7 @@ The nostr server will send back a message response, and inside the body there wi
 - UserHealth
   - auth type: __User__
   - This methods has an __empty__ __request__ body
-  - This methods has an __empty__ __response__ body
+  - output: [UserHealthState](#UserHealthState)
 
 # HTTP API DEFINITION
 
@@ -817,7 +817,7 @@ The nostr server will send back a message response, and inside the body there wi
   - http method: __post__
   - http route: __/api/user/health__
   - This methods has an __empty__ __request__ body
-  - This methods has an __empty__ __response__ body
+  - output: [UserHealthState](#UserHealthState)
 
 # INPUTS AND OUTPUTS
 
@@ -1291,6 +1291,9 @@ The nostr server will send back a message response, and inside the body there wi
 ### UseInviteLinkRequest
   - __invite_token__: _string_
 
+### UserHealthState
+  - __downtime_reason__: _string_
+
 ### UserInfo
   - __balance__: _number_
   - __bridge_url__: _string_
diff --git a/proto/autogenerated/go/http_client.go b/proto/autogenerated/go/http_client.go
index 8319449a..522df237 100644
--- a/proto/autogenerated/go/http_client.go
+++ b/proto/autogenerated/go/http_client.go
@@ -125,7 +125,7 @@ type Client struct {
 	UpdateChannelPolicy         func(req UpdateChannelPolicyRequest) error
 	UpdateUserOffer             func(req OfferConfig) error
 	UseInviteLink               func(req UseInviteLinkRequest) error
-	UserHealth                  func() error
+	UserHealth                  func() (*UserHealthState, error)
 }
 
 func NewClient(params ClientParams) *Client {
@@ -1904,26 +1904,31 @@ func NewClient(params ClientParams) *Client {
 			}
 			return nil
 		},
-		UserHealth: func() error {
+		UserHealth: func() (*UserHealthState, error) {
 			auth, err := params.RetrieveUserAuth()
 			if err != nil {
-				return err
+				return nil, err
 			}
 			finalRoute := "/api/user/health"
 			body := []byte{}
 			resBody, err := doPostRequest(params.BaseURL+finalRoute, body, auth)
 			if err != nil {
-				return err
+				return nil, err
 			}
 			result := ResultError{}
 			err = json.Unmarshal(resBody, &result)
 			if err != nil {
-				return err
+				return nil, err
 			}
 			if result.Status == "ERROR" {
-				return fmt.Errorf(result.Reason)
+				return nil, fmt.Errorf(result.Reason)
 			}
-			return nil
+			res := UserHealthState{}
+			err = json.Unmarshal(resBody, &res)
+			if err != nil {
+				return nil, err
+			}
+			return &res, nil
 		},
 	}
 }
diff --git a/proto/autogenerated/go/types.go b/proto/autogenerated/go/types.go
index 28113249..c82ae57f 100644
--- a/proto/autogenerated/go/types.go
+++ b/proto/autogenerated/go/types.go
@@ -555,6 +555,9 @@ type UsageMetrics struct {
 type UseInviteLinkRequest struct {
 	Invite_token string `json:"invite_token"`
 }
+type UserHealthState struct {
+	Downtime_reason string `json:"downtime_reason"`
+}
 type UserInfo struct {
 	Balance               int64  `json:"balance"`
 	Bridge_url            string `json:"bridge_url"`
diff --git a/proto/autogenerated/ts/express_server.ts b/proto/autogenerated/ts/express_server.ts
index d84f9c48..f76044ea 100644
--- a/proto/autogenerated/ts/express_server.ts
+++ b/proto/autogenerated/ts/express_server.ts
@@ -612,7 +612,7 @@ export default (methods: Types.ServerMethods, opts: ServerOptions) => {
                                 throw new Error('method UserHealth not found' )
                             } else {
                                 opStats.validate = opStats.guard
-                                await methods.UserHealth({...operation, ctx}); responses.push({ status: 'OK' })
+                                const res = await methods.UserHealth({...operation, ctx}); responses.push({ status: 'OK', ...res  })
                                 opStats.handle = process.hrtime.bigint()
                                 callsMetrics.push({ ...opInfo, ...opStats, ...ctx })
                             }
@@ -1799,9 +1799,9 @@ export default (methods: Types.ServerMethods, opts: ServerOptions) => {
             stats.validate = stats.guard
             const query = req.query
             const params = req.params
-             await methods.UserHealth({rpcName:'UserHealth', ctx:authContext })
+            const response =  await methods.UserHealth({rpcName:'UserHealth', ctx:authContext })
             stats.handle = process.hrtime.bigint()
-            res.json({status: 'OK'})
+            res.json({status: 'OK', ...response})
             opts.metricsCallback([{ ...info, ...stats, ...authContext }])
         } catch (ex) { const e = ex as any; logErrorAndReturnResponse(e, e.message || e, res, logger, { ...info, ...stats, ...authCtx }, opts.metricsCallback); if (opts.throwErrors) throw e }
     })
diff --git a/proto/autogenerated/ts/http_client.ts b/proto/autogenerated/ts/http_client.ts
index ab40fdae..0097d29e 100644
--- a/proto/autogenerated/ts/http_client.ts
+++ b/proto/autogenerated/ts/http_client.ts
@@ -17,57 +17,57 @@ export type ClientParams = {
     checkResult?: true
 }
 export default (params: ClientParams) => ({
-    AddApp: async (request: Types.AddAppRequest): Promise<ResultError | ({ status: 'OK' } & Types.AuthApp)> => {
+    AddApp: async (request: Types.AddAppRequest): Promise<ResultError | ({ status: 'OK' }& Types.AuthApp)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/app/add'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.AuthAppValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    AddAppInvoice: async (request: Types.AddAppInvoiceRequest): Promise<ResultError | ({ status: 'OK' } & Types.NewInvoiceResponse)> => {
+    AddAppInvoice: async (request: Types.AddAppInvoiceRequest): Promise<ResultError | ({ status: 'OK' }& Types.NewInvoiceResponse)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/add/invoice'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.NewInvoiceResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    AddAppUser: async (request: Types.AddAppUserRequest): Promise<ResultError | ({ status: 'OK' } & Types.AppUser)> => {
+    AddAppUser: async (request: Types.AddAppUserRequest): Promise<ResultError | ({ status: 'OK' }& Types.AppUser)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/user/add'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.AppUserValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    AddAppUserInvoice: async (request: Types.AddAppUserInvoiceRequest): Promise<ResultError | ({ status: 'OK' } & Types.NewInvoiceResponse)> => {
+    AddAppUserInvoice: async (request: Types.AddAppUserInvoiceRequest): Promise<ResultError | ({ status: 'OK' }& Types.NewInvoiceResponse)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/user/add/invoice'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.NewInvoiceResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
@@ -79,62 +79,62 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/admin/peer'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    AddProduct: async (request: Types.AddProductRequest): Promise<ResultError | ({ status: 'OK' } & Types.Product)> => {
+    AddProduct: async (request: Types.AddProductRequest): Promise<ResultError | ({ status: 'OK' }& Types.Product)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/product/add'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.ProductValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    AddUserOffer: async (request: Types.OfferConfig): Promise<ResultError | ({ status: 'OK' } & Types.OfferId)> => {
+    AddUserOffer: async (request: Types.OfferConfig): Promise<ResultError | ({ status: 'OK' }& Types.OfferId)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/offer/add'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.OfferIdValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    AuthApp: async (request: Types.AuthAppRequest): Promise<ResultError | ({ status: 'OK' } & Types.AuthApp)> => {
+    AuthApp: async (request: Types.AuthAppRequest): Promise<ResultError | ({ status: 'OK' }& Types.AuthApp)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/app/auth'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.AuthAppValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    AuthorizeDebit: async (request: Types.DebitAuthorizationRequest): Promise<ResultError | ({ status: 'OK' } & Types.DebitAuthorization)> => {
+    AuthorizeDebit: async (request: Types.DebitAuthorizationRequest): Promise<ResultError | ({ status: 'OK' }& Types.DebitAuthorization)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/debit/authorize'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.DebitAuthorizationValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
@@ -146,73 +146,73 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/user/debit/ban'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    BanUser: async (request: Types.BanUserRequest): Promise<ResultError | ({ status: 'OK' } & Types.BanUserResponse)> => {
+    BanUser: async (request: Types.BanUserRequest): Promise<ResultError | ({ status: 'OK' }& Types.BanUserResponse)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/user/ban'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.BanUserResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    BatchUser: async (requests: Types.UserMethodInputs[]): Promise<ResultError | ({ status: 'OK', responses: (Types.UserMethodOutputs)[] })> => {
+    BatchUser: async (requests:Types.UserMethodInputs[]): Promise<ResultError | ({ status: 'OK', responses:( Types.UserMethodOutputs)[] })> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/batch'
-        const { data } = await axios.post(params.baseUrl + finalRoute, { requests }, { headers: { 'authorization': auth } })
+        const { data } = await axios.post(params.baseUrl + finalRoute, {requests}, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return { status: 'OK', ...data }
-        }
+        } 
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    CloseChannel: async (request: Types.CloseChannelRequest): Promise<ResultError | ({ status: 'OK' } & Types.CloseChannelResponse)> => {
+    CloseChannel: async (request: Types.CloseChannelRequest): Promise<ResultError | ({ status: 'OK' }& Types.CloseChannelResponse)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/channel/close'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.CloseChannelResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    CreateOneTimeInviteLink: async (request: Types.CreateOneTimeInviteLinkRequest): Promise<ResultError | ({ status: 'OK' } & Types.CreateOneTimeInviteLinkResponse)> => {
+    CreateOneTimeInviteLink: async (request: Types.CreateOneTimeInviteLinkRequest): Promise<ResultError | ({ status: 'OK' }& Types.CreateOneTimeInviteLinkResponse)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/app/invite/create'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.CreateOneTimeInviteLinkResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    DecodeInvoice: async (request: Types.DecodeInvoiceRequest): Promise<ResultError | ({ status: 'OK' } & Types.DecodeInvoiceResponse)> => {
+    DecodeInvoice: async (request: Types.DecodeInvoiceRequest): Promise<ResultError | ({ status: 'OK' }& Types.DecodeInvoiceResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/invoice/decode'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.DecodeInvoiceResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
@@ -224,7 +224,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/user/offer/delete'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -235,7 +235,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/user/debit/edit'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -246,7 +246,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/encryption/exchange'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -257,127 +257,127 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/guest/npub/enroll/admin'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetApp: async (): Promise<ResultError | ({ status: 'OK' } & Types.Application)> => {
+    GetApp: async (): Promise<ResultError | ({ status: 'OK' }& Types.Application)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/get'
         const { data } = await axios.post(params.baseUrl + finalRoute, {}, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.ApplicationValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetAppUser: async (request: Types.GetAppUserRequest): Promise<ResultError | ({ status: 'OK' } & Types.AppUser)> => {
+    GetAppUser: async (request: Types.GetAppUserRequest): Promise<ResultError | ({ status: 'OK' }& Types.AppUser)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/user/get'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.AppUserValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetAppUserLNURLInfo: async (request: Types.GetAppUserLNURLInfoRequest): Promise<ResultError | ({ status: 'OK' } & Types.LnurlPayInfoResponse)> => {
+    GetAppUserLNURLInfo: async (request: Types.GetAppUserLNURLInfoRequest): Promise<ResultError | ({ status: 'OK' }& Types.LnurlPayInfoResponse)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/user/lnurl/pay/info'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LnurlPayInfoResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetAppsMetrics: async (request: Types.AppsMetricsRequest): Promise<ResultError | ({ status: 'OK' } & Types.AppsMetrics)> => {
+    GetAppsMetrics: async (request: Types.AppsMetricsRequest): Promise<ResultError | ({ status: 'OK' }& Types.AppsMetrics)> => {
         const auth = await params.retrieveMetricsAuth()
         if (auth === null) throw new Error('retrieveMetricsAuth() returned null')
         let finalRoute = '/api/reports/apps'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.AppsMetricsValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetDebitAuthorizations: async (): Promise<ResultError | ({ status: 'OK' } & Types.DebitAuthorizations)> => {
+    GetDebitAuthorizations: async (): Promise<ResultError | ({ status: 'OK' }& Types.DebitAuthorizations)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/debit/get'
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.DebitAuthorizationsValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetHttpCreds: async (cb: (v: ResultError | ({ status: 'OK' } & Types.HttpCreds)) => void): Promise<void> => { throw new Error('http streams are not supported') },
-    GetInviteLinkState: async (request: Types.GetInviteTokenStateRequest): Promise<ResultError | ({ status: 'OK' } & Types.GetInviteTokenStateResponse)> => {
+    GetHttpCreds: async (cb: (v:ResultError | ({ status: 'OK' }& Types.HttpCreds)) => void): Promise<void> => { throw  new Error('http streams are not supported')},
+    GetInviteLinkState: async (request: Types.GetInviteTokenStateRequest): Promise<ResultError | ({ status: 'OK' }& Types.GetInviteTokenStateResponse)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/app/invite/get'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.GetInviteTokenStateResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetLNURLChannelLink: async (): Promise<ResultError | ({ status: 'OK' } & Types.LnurlLinkResponse)> => {
+    GetLNURLChannelLink: async (): Promise<ResultError | ({ status: 'OK' }& Types.LnurlLinkResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/lnurl_channel/url'
         const { data } = await axios.post(params.baseUrl + finalRoute, {}, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LnurlLinkResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetLiveDebitRequests: async (cb: (v: ResultError | ({ status: 'OK' } & Types.LiveDebitRequest)) => void): Promise<void> => { throw new Error('http streams are not supported') },
-    GetLiveUserOperations: async (cb: (v: ResultError | ({ status: 'OK' } & Types.LiveUserOperation)) => void): Promise<void> => { throw new Error('http streams are not supported') },
-    GetLndMetrics: async (request: Types.LndMetricsRequest): Promise<ResultError | ({ status: 'OK' } & Types.LndMetrics)> => {
+    GetLiveDebitRequests: async (cb: (v:ResultError | ({ status: 'OK' }& Types.LiveDebitRequest)) => void): Promise<void> => { throw  new Error('http streams are not supported')},
+    GetLiveUserOperations: async (cb: (v:ResultError | ({ status: 'OK' }& Types.LiveUserOperation)) => void): Promise<void> => { throw  new Error('http streams are not supported')},
+    GetLndMetrics: async (request: Types.LndMetricsRequest): Promise<ResultError | ({ status: 'OK' }& Types.LndMetrics)> => {
         const auth = await params.retrieveMetricsAuth()
         if (auth === null) throw new Error('retrieveMetricsAuth() returned null')
         let finalRoute = '/api/reports/lnd'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LndMetricsValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetLnurlPayInfo: async (query: Types.GetLnurlPayInfo_Query): Promise<ResultError | ({ status: 'OK' } & Types.LnurlPayInfoResponse)> => {
+    GetLnurlPayInfo: async (query: Types.GetLnurlPayInfo_Query): Promise<ResultError | ({ status: 'OK' }& Types.LnurlPayInfoResponse)> => {
         const auth = await params.retrieveGuestAuth()
         if (auth === null) throw new Error('retrieveGuestAuth() returned null')
         let finalRoute = '/api/guest/lnurl_pay/info'
@@ -385,29 +385,29 @@ export default (params: ClientParams) => ({
         finalRoute = finalRoute + (q === '' ? '' : '?' + q)
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LnurlPayInfoResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetLnurlPayLink: async (): Promise<ResultError | ({ status: 'OK' } & Types.LnurlLinkResponse)> => {
+    GetLnurlPayLink: async (): Promise<ResultError | ({ status: 'OK' }& Types.LnurlLinkResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/lnurl_pay/link'
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LnurlLinkResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetLnurlWithdrawInfo: async (query: Types.GetLnurlWithdrawInfo_Query): Promise<ResultError | ({ status: 'OK' } & Types.LnurlWithdrawInfoResponse)> => {
+    GetLnurlWithdrawInfo: async (query: Types.GetLnurlWithdrawInfo_Query): Promise<ResultError | ({ status: 'OK' }& Types.LnurlWithdrawInfoResponse)> => {
         const auth = await params.retrieveGuestAuth()
         if (auth === null) throw new Error('retrieveGuestAuth() returned null')
         let finalRoute = '/api/guest/lnurl_withdraw/info'
@@ -415,171 +415,171 @@ export default (params: ClientParams) => ({
         finalRoute = finalRoute + (q === '' ? '' : '?' + q)
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LnurlWithdrawInfoResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetLnurlWithdrawLink: async (): Promise<ResultError | ({ status: 'OK' } & Types.LnurlLinkResponse)> => {
+    GetLnurlWithdrawLink: async (): Promise<ResultError | ({ status: 'OK' }& Types.LnurlLinkResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/lnurl_withdraw/link'
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LnurlLinkResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetMigrationUpdate: async (cb: (v: ResultError | ({ status: 'OK' } & Types.MigrationUpdate)) => void): Promise<void> => { throw new Error('http streams are not supported') },
-    GetNPubLinkingState: async (request: Types.GetNPubLinking): Promise<ResultError | ({ status: 'OK' } & Types.NPubLinking)> => {
+    GetMigrationUpdate: async (cb: (v:ResultError | ({ status: 'OK' }& Types.MigrationUpdate)) => void): Promise<void> => { throw  new Error('http streams are not supported')},
+    GetNPubLinkingState: async (request: Types.GetNPubLinking): Promise<ResultError | ({ status: 'OK' }& Types.NPubLinking)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/user/npub/state'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.NPubLinkingValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetPaymentState: async (request: Types.GetPaymentStateRequest): Promise<ResultError | ({ status: 'OK' } & Types.PaymentState)> => {
+    GetPaymentState: async (request: Types.GetPaymentStateRequest): Promise<ResultError | ({ status: 'OK' }& Types.PaymentState)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/payment/state'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.PaymentStateValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetSeed: async (): Promise<ResultError | ({ status: 'OK' } & Types.LndSeed)> => {
+    GetSeed: async (): Promise<ResultError | ({ status: 'OK' }& Types.LndSeed)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/seed'
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LndSeedValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetUsageMetrics: async (): Promise<ResultError | ({ status: 'OK' } & Types.UsageMetrics)> => {
+    GetUsageMetrics: async (): Promise<ResultError | ({ status: 'OK' }& Types.UsageMetrics)> => {
         const auth = await params.retrieveMetricsAuth()
         if (auth === null) throw new Error('retrieveMetricsAuth() returned null')
         let finalRoute = '/api/reports/usage'
         const { data } = await axios.post(params.baseUrl + finalRoute, {}, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.UsageMetricsValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetUserInfo: async (): Promise<ResultError | ({ status: 'OK' } & Types.UserInfo)> => {
+    GetUserInfo: async (): Promise<ResultError | ({ status: 'OK' }& Types.UserInfo)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/info'
         const { data } = await axios.post(params.baseUrl + finalRoute, {}, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.UserInfoValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetUserOffer: async (request: Types.OfferId): Promise<ResultError | ({ status: 'OK' } & Types.OfferConfig)> => {
+    GetUserOffer: async (request: Types.OfferId): Promise<ResultError | ({ status: 'OK' }& Types.OfferConfig)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/offer/get'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.OfferConfigValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetUserOfferInvoices: async (request: Types.GetUserOfferInvoicesReq): Promise<ResultError | ({ status: 'OK' } & Types.OfferInvoices)> => {
+    GetUserOfferInvoices: async (request: Types.GetUserOfferInvoicesReq): Promise<ResultError | ({ status: 'OK' }& Types.OfferInvoices)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/offer/get/invoices'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.OfferInvoicesValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetUserOffers: async (): Promise<ResultError | ({ status: 'OK' } & Types.UserOffers)> => {
+    GetUserOffers: async (): Promise<ResultError | ({ status: 'OK' }& Types.UserOffers)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/offers/get'
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.UserOffersValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    GetUserOperations: async (request: Types.GetUserOperationsRequest): Promise<ResultError | ({ status: 'OK' } & Types.GetUserOperationsResponse)> => {
+    GetUserOperations: async (request: Types.GetUserOperationsRequest): Promise<ResultError | ({ status: 'OK' }& Types.GetUserOperationsResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/operations'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.GetUserOperationsResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    HandleLnurlAddress: async (routeParams: Types.HandleLnurlAddress_RouteParams): Promise<ResultError | ({ status: 'OK' } & Types.LnurlPayInfoResponse)> => {
+    HandleLnurlAddress: async (routeParams: Types.HandleLnurlAddress_RouteParams): Promise<ResultError | ({ status: 'OK' }& Types.LnurlPayInfoResponse)> => {
         const auth = await params.retrieveGuestAuth()
         if (auth === null) throw new Error('retrieveGuestAuth() returned null')
         let finalRoute = '/.well-known/lnurlp/:address_name'
         finalRoute = finalRoute.replace(':address_name', routeParams['address_name'])
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LnurlPayInfoResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    HandleLnurlPay: async (query: Types.HandleLnurlPay_Query): Promise<ResultError | ({ status: 'OK' } & Types.HandleLnurlPayResponse)> => {
+    HandleLnurlPay: async (query: Types.HandleLnurlPay_Query): Promise<ResultError | ({ status: 'OK' }& Types.HandleLnurlPayResponse)> => {
         const auth = await params.retrieveGuestAuth()
         if (auth === null) throw new Error('retrieveGuestAuth() returned null')
         let finalRoute = '/api/guest/lnurl_pay/handle'
@@ -587,9 +587,9 @@ export default (params: ClientParams) => ({
         finalRoute = finalRoute + (q === '' ? '' : '?' + q)
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.HandleLnurlPayResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
@@ -603,7 +603,7 @@ export default (params: ClientParams) => ({
         finalRoute = finalRoute + (q === '' ? '' : '?' + q)
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -614,7 +614,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/health'
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -625,68 +625,68 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/guest/npub/link'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    ListChannels: async (): Promise<ResultError | ({ status: 'OK' } & Types.LndChannels)> => {
+    ListChannels: async (): Promise<ResultError | ({ status: 'OK' }& Types.LndChannels)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/channels'
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LndChannelsValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    LndGetInfo: async (request: Types.LndGetInfoRequest): Promise<ResultError | ({ status: 'OK' } & Types.LndGetInfoResponse)> => {
+    LndGetInfo: async (request: Types.LndGetInfoRequest): Promise<ResultError | ({ status: 'OK' }& Types.LndGetInfoResponse)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/lnd/getinfo'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.LndGetInfoResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    NewAddress: async (request: Types.NewAddressRequest): Promise<ResultError | ({ status: 'OK' } & Types.NewAddressResponse)> => {
+    NewAddress: async (request: Types.NewAddressRequest): Promise<ResultError | ({ status: 'OK' }& Types.NewAddressResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/chain/new'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.NewAddressResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    NewInvoice: async (request: Types.NewInvoiceRequest): Promise<ResultError | ({ status: 'OK' } & Types.NewInvoiceResponse)> => {
+    NewInvoice: async (request: Types.NewInvoiceRequest): Promise<ResultError | ({ status: 'OK' }& Types.NewInvoiceResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/invoice/new'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.NewInvoiceResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    NewProductInvoice: async (query: Types.NewProductInvoice_Query): Promise<ResultError | ({ status: 'OK' } & Types.NewInvoiceResponse)> => {
+    NewProductInvoice: async (query: Types.NewProductInvoice_Query): Promise<ResultError | ({ status: 'OK' }& Types.NewInvoiceResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/product/get/invoice'
@@ -694,79 +694,79 @@ export default (params: ClientParams) => ({
         finalRoute = finalRoute + (q === '' ? '' : '?' + q)
         const { data } = await axios.get(params.baseUrl + finalRoute, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.NewInvoiceResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    OpenChannel: async (request: Types.OpenChannelRequest): Promise<ResultError | ({ status: 'OK' } & Types.OpenChannelResponse)> => {
+    OpenChannel: async (request: Types.OpenChannelRequest): Promise<ResultError | ({ status: 'OK' }& Types.OpenChannelResponse)> => {
         const auth = await params.retrieveAdminAuth()
         if (auth === null) throw new Error('retrieveAdminAuth() returned null')
         let finalRoute = '/api/admin/channel/open'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.OpenChannelResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    PayAddress: async (request: Types.PayAddressRequest): Promise<ResultError | ({ status: 'OK' } & Types.PayAddressResponse)> => {
+    PayAddress: async (request: Types.PayAddressRequest): Promise<ResultError | ({ status: 'OK' }& Types.PayAddressResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/chain/pay'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.PayAddressResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    PayAppUserInvoice: async (request: Types.PayAppUserInvoiceRequest): Promise<ResultError | ({ status: 'OK' } & Types.PayInvoiceResponse)> => {
+    PayAppUserInvoice: async (request: Types.PayAppUserInvoiceRequest): Promise<ResultError | ({ status: 'OK' }& Types.PayInvoiceResponse)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/invoice/pay'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.PayInvoiceResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    PayInvoice: async (request: Types.PayInvoiceRequest): Promise<ResultError | ({ status: 'OK' } & Types.PayInvoiceResponse)> => {
+    PayInvoice: async (request: Types.PayInvoiceRequest): Promise<ResultError | ({ status: 'OK' }& Types.PayInvoiceResponse)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/invoice/pay'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.PayInvoiceResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    RequestNPubLinkingToken: async (request: Types.RequestNPubLinkingTokenRequest): Promise<ResultError | ({ status: 'OK' } & Types.RequestNPubLinkingTokenResponse)> => {
+    RequestNPubLinkingToken: async (request: Types.RequestNPubLinkingTokenRequest): Promise<ResultError | ({ status: 'OK' }& Types.RequestNPubLinkingTokenResponse)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/user/npub/token'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.RequestNPubLinkingTokenResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
@@ -778,20 +778,20 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/user/debit/reset'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    ResetNPubLinkingToken: async (request: Types.RequestNPubLinkingTokenRequest): Promise<ResultError | ({ status: 'OK' } & Types.RequestNPubLinkingTokenResponse)> => {
+    ResetNPubLinkingToken: async (request: Types.RequestNPubLinkingTokenRequest): Promise<ResultError | ({ status: 'OK' }& Types.RequestNPubLinkingTokenResponse)> => {
         const auth = await params.retrieveAppAuth()
         if (auth === null) throw new Error('retrieveAppAuth() returned null')
         let finalRoute = '/api/app/user/npub/token/reset'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.RequestNPubLinkingTokenResponseValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
@@ -803,7 +803,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/user/debit/finish'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -814,7 +814,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/app/internal/pay'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -825,7 +825,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/app/user/internal/pay'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -836,7 +836,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/app/mock/blance/set'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -847,7 +847,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/app/mock/user/blance/set'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -858,20 +858,20 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/lnd/mock/invoice/paid'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    UpdateCallbackUrl: async (request: Types.CallbackUrl): Promise<ResultError | ({ status: 'OK' } & Types.CallbackUrl)> => {
+    UpdateCallbackUrl: async (request: Types.CallbackUrl): Promise<ResultError | ({ status: 'OK' }& Types.CallbackUrl)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/cb/update'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             const result = data
-            if (!params.checkResult) return { status: 'OK', ...result }
+            if(!params.checkResult) return { status: 'OK', ...result }
             const error = Types.CallbackUrlValidate(result)
             if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
@@ -883,7 +883,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/admin/channel/policy/update'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -894,7 +894,7 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/user/offer/update'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
@@ -905,19 +905,22 @@ export default (params: ClientParams) => ({
         let finalRoute = '/api/guest/invite'
         const { data } = await axios.post(params.baseUrl + finalRoute, request, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
+        if (data.status === 'OK') { 
             return data
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    UserHealth: async (): Promise<ResultError | ({ status: 'OK' })> => {
+    UserHealth: async (): Promise<ResultError | ({ status: 'OK' }& Types.UserHealthState)> => {
         const auth = await params.retrieveUserAuth()
         if (auth === null) throw new Error('retrieveUserAuth() returned null')
         let finalRoute = '/api/user/health'
         const { data } = await axios.post(params.baseUrl + finalRoute, {}, { headers: { 'authorization': auth } })
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
-        if (data.status === 'OK') {
-            return data
+        if (data.status === 'OK') { 
+            const result = data
+            if(!params.checkResult) return { status: 'OK', ...result }
+            const error = Types.UserHealthStateValidate(result)
+            if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
diff --git a/proto/autogenerated/ts/nostr_client.ts b/proto/autogenerated/ts/nostr_client.ts
index ff4eda05..286b6414 100644
--- a/proto/autogenerated/ts/nostr_client.ts
+++ b/proto/autogenerated/ts/nostr_client.ts
@@ -701,14 +701,17 @@ export default (params: NostrClientParams,  send: (to:string, message: NostrRequ
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
-    UserHealth: async (): Promise<ResultError | ({ status: 'OK' })> => {
+    UserHealth: async (): Promise<ResultError | ({ status: 'OK' }& Types.UserHealthState)> => {
         const auth = await params.retrieveNostrUserAuth()
         if (auth === null) throw new Error('retrieveNostrUserAuth() returned null')
         const nostrRequest: NostrRequest = {}
         const data = await send(params.pubDestination, {rpcName:'UserHealth',authIdentifier:auth, ...nostrRequest }) 
         if (data.status === 'ERROR' && typeof data.reason === 'string') return data
         if (data.status === 'OK') { 
-            return data
+            const result = data
+            if(!params.checkResult) return { status: 'OK', ...result }
+            const error = Types.UserHealthStateValidate(result)
+            if (error === null) { return { status: 'OK', ...result } } else return { status: 'ERROR', reason: error.message }
         }
         return { status: 'ERROR', reason: 'invalid response' }
     },
diff --git a/proto/autogenerated/ts/nostr_transport.ts b/proto/autogenerated/ts/nostr_transport.ts
index 99cceb6d..96ad70e8 100644
--- a/proto/autogenerated/ts/nostr_transport.ts
+++ b/proto/autogenerated/ts/nostr_transport.ts
@@ -494,7 +494,7 @@ export default (methods: Types.ServerMethods, opts: NostrOptions) => {
                                         throw new Error('method not defined: UserHealth')
                                     } else {
                                         opStats.validate = opStats.guard
-                                        await methods.UserHealth({...operation, ctx}); responses.push({ status: 'OK' })
+                                        const res = await methods.UserHealth({...operation, ctx}); responses.push({ status: 'OK', ...res  })
                                         opStats.handle = process.hrtime.bigint()
                                         callsMetrics.push({ ...opInfo, ...opStats, ...ctx })
                                     }
@@ -1114,9 +1114,9 @@ export default (methods: Types.ServerMethods, opts: NostrOptions) => {
                     stats.guard = process.hrtime.bigint()
                     authCtx = authContext
                     stats.validate = stats.guard
-                    await methods.UserHealth({rpcName:'UserHealth', ctx:authContext })
+                    const response = await methods.UserHealth({rpcName:'UserHealth', ctx:authContext })
                     stats.handle = process.hrtime.bigint()
-                    res({status: 'OK'})
+                    res({status: 'OK', ...response})
                     opts.metricsCallback([{ ...info, ...stats, ...authContext }])
                 }catch(ex){ const e = ex as any; logErrorAndReturnResponse(e, e.message || e, res, logger, { ...info, ...stats, ...authCtx }, opts.metricsCallback); if (opts.throwErrors) throw e }
                 break
diff --git a/proto/autogenerated/ts/types.ts b/proto/autogenerated/ts/types.ts
index f7a9b021..8609d007 100644
--- a/proto/autogenerated/ts/types.ts
+++ b/proto/autogenerated/ts/types.ts
@@ -274,7 +274,7 @@ export type UseInviteLink_Input = {rpcName:'UseInviteLink', req: UseInviteLinkRe
 export type UseInviteLink_Output = ResultError | { status: 'OK' }
 
 export type UserHealth_Input = {rpcName:'UserHealth'}
-export type UserHealth_Output = ResultError | { status: 'OK' }
+export type UserHealth_Output = ResultError | ({ status: 'OK' } & UserHealthState)
 
 export type ServerMethods = {
     AddApp?: (req: AddApp_Input & {ctx: AdminContext }) => Promise<AuthApp>
@@ -347,7 +347,7 @@ export type ServerMethods = {
     UpdateChannelPolicy?: (req: UpdateChannelPolicy_Input & {ctx: AdminContext }) => Promise<void>
     UpdateUserOffer?: (req: UpdateUserOffer_Input & {ctx: UserContext }) => Promise<void>
     UseInviteLink?: (req: UseInviteLink_Input & {ctx: GuestWithPubContext }) => Promise<void>
-    UserHealth?: (req: UserHealth_Input & {ctx: UserContext }) => Promise<void>
+    UserHealth?: (req: UserHealth_Input & {ctx: UserContext }) => Promise<UserHealthState>
 }
 
 export enum AddressType {
@@ -3169,6 +3169,24 @@ export const UseInviteLinkRequestValidate = (o?: UseInviteLinkRequest, opts: Use
     return null
 }
 
+export type UserHealthState = {
+    downtime_reason: string
+}
+export const UserHealthStateOptionalFields: [] = []
+export type UserHealthStateOptions = OptionsBaseMessage & {
+    checkOptionalsAreSet?: []
+    downtime_reason_CustomCheck?: (v: string) => boolean
+}
+export const UserHealthStateValidate = (o?: UserHealthState, opts: UserHealthStateOptions = {}, path: string = 'UserHealthState::root.'): Error | null => {
+    if (opts.checkOptionalsAreSet && opts.allOptionalsAreSet) return new Error(path + ': only one of checkOptionalsAreSet or allOptionalNonDefault can be set for each message')
+    if (typeof o !== 'object' || o === null) return new Error(path + ': object is not an instance of an object or is null')
+
+    if (typeof o.downtime_reason !== 'string') return new Error(`${path}.downtime_reason: is not a string`)
+    if (opts.downtime_reason_CustomCheck && !opts.downtime_reason_CustomCheck(o.downtime_reason)) return new Error(`${path}.downtime_reason: custom check failed`)
+
+    return null
+}
+
 export type UserInfo = {
     balance: number
     bridge_url: string
diff --git a/proto/service/methods.proto b/proto/service/methods.proto
index 4ac703ad..9b8e9f42 100644
--- a/proto/service/methods.proto
+++ b/proto/service/methods.proto
@@ -364,7 +364,7 @@ service LightningPub {
     // </App>
     
     // <User>
-    rpc UserHealth(structs.Empty)returns(structs.Empty){
+    rpc UserHealth(structs.Empty)returns(structs.UserHealthState){
         option (auth_type)  = "User";
         option (http_method) = "post";
         option (http_route) = "/api/user/health";
diff --git a/proto/service/structs.proto b/proto/service/structs.proto
index 409c1b16..53e8ecf6 100644
--- a/proto/service/structs.proto
+++ b/proto/service/structs.proto
@@ -15,6 +15,10 @@ message EncryptionExchangeRequest {
     string deviceId = 2;
 }
 
+message UserHealthState {
+    string downtime_reason = 1;
+}
+
 message UsageMetric {
     int64 processed_at_ms = 1;
     int64 parsed_in_nano = 2;
diff --git a/src/services/serverMethods/index.ts b/src/services/serverMethods/index.ts
index 1b4a2832..5b17a7ee 100644
--- a/src/services/serverMethods/index.ts
+++ b/src/services/serverMethods/index.ts
@@ -73,7 +73,10 @@ export default (mainHandler: Main): Types.ServerMethods => {
             if (err != null) throw new Error(err.message)
             await mainHandler.paymentManager.SetMockInvoiceAsPaid(req)
         },
-        UserHealth: async () => { await mainHandler.lnd.Health() },
+        UserHealth: async () => {
+            try { await mainHandler.lnd.Health(); return { downtime_reason: "" } }
+            catch (e: any) { return { downtime_reason: e.message } }
+        },
         GetUserInfo: ({ ctx }) => mainHandler.appUserManager.GetUserInfo(ctx),
         UpdateCallbackUrl: async ({ ctx, req }) => {
             return mainHandler.appUserManager.UpdateCallbackUrl(ctx, req)