chore: simplify keycard rpc counter (#17244)

* chore: simplify keycard rpc counter

* fix: remove service callRPC wrapper

src/app_service/service/keycardV2/async_tasks.nim

@@ -2,12 +2,11 @@ type
   AsyncInitializeTaskArg = ref object of QObjectTaskArg
     pin: string
     puk: string
-    rpcCounter: int
 
 proc asyncInitializeTask(argEncoded: string) {.gcsafe, nimcall.} =
   let arg = decode[AsyncInitializeTaskArg](argEncoded)
   try:
-    let response = callRPC(arg.rpcCounter, "Initialize", %*{"pin": arg.pin, "puk": arg.puk})
+    let response = callRPC("Initialize", %*{"pin": arg.pin, "puk": arg.puk})
     arg.finish(%*{
       "response": response,
       "error": ""
@@ -20,12 +19,11 @@ proc asyncInitializeTask(argEncoded: string) {.gcsafe, nimcall.} =
 type
   AsyncAuthorizeArg = ref object of QObjectTaskArg
     pin: string
-    rpcCounter: int
 
 proc asyncAuthorizeTask(argEncoded: string) {.gcsafe, nimcall.} =
   let arg = decode[AsyncInitializeTaskArg](argEncoded)
   try:
-    let response = callRPC(arg.rpcCounter, "Authorize", %*{"pin": arg.pin})
+    let response = callRPC("Authorize", %*{"pin": arg.pin})
     arg.finish(%*{
       "response": response,
       "error": ""
@@ -38,14 +36,13 @@ proc asyncAuthorizeTask(argEncoded: string) {.gcsafe, nimcall.} =
 type
   AsyncLoadMnemonicArg = ref object of QObjectTaskArg
     mnemonic: string
-    rpcCounter: int
 
 proc asyncLoadMnemonicTask(argEncoded: string) {.gcsafe, nimcall.} =
   let arg = decode[AsyncLoadMnemonicArg](argEncoded)
   try:
-    let response = callRPC(arg.rpcCounter, "LoadMnemonic", %*{"mnemonic": arg.mnemonic})
+    let loadMnemonicResponse = callRPC("LoadMnemonic", %*{"mnemonic": arg.mnemonic})
     arg.finish(%*{
-      "response": response,
+      "response": loadMnemonicResponse,
       "error": ""
     })
   except Exception as e:
@@ -55,12 +52,11 @@ proc asyncLoadMnemonicTask(argEncoded: string) {.gcsafe, nimcall.} =
 
 type
   AsyncExportRecoverKeysArg = ref object of QObjectTaskArg
-    rpcCounter: int
 
 proc asyncExportRecoverKeysTask(argEncoded: string) {.gcsafe, nimcall.} =
   let arg = decode[AsyncExportRecoverKeysArg](argEncoded)
   try:
-    let response = callRPC(arg.rpcCounter, "ExportRecoverKeys")
+    let response = callRPC("ExportRecoverKeys")
     arg.finish(%*{
       "response": response,
       "error": ""
@@ -72,12 +68,11 @@ proc asyncExportRecoverKeysTask(argEncoded: string) {.gcsafe, nimcall.} =
 
 type
   AsyncExportLoginKeysArg = ref object of QObjectTaskArg
-    rpcCounter: int
 
 proc asyncExportLoginKeysTask(argEncoded: string) {.gcsafe, nimcall.} =
   let arg = decode[AsyncExportLoginKeysArg](argEncoded)
   try:
-    let response = callRPC(arg.rpcCounter, "ExportLoginKeys")
+    let response = callRPC("ExportLoginKeys")
     arg.finish(%*{
       "response": response,
       "error": ""

src/app_service/service/keycardV2/service.nim

@@ -8,7 +8,10 @@ import ../../../backend/response_type
 import ../../../constants as status_const
 import ./dto
 
-proc callRPC*(rpcCounter: int, methodName: string, params: JsonNode = %*{}): string  =
+var rpcCounter: int = 0
+
+proc callRPC*(methodName: string, params: JsonNode = %*{}): string  =
+    rpcCounter += 1
     let request = %*{
       "id": rpcCounter,
       "method": "keycard." & methodName,
@@ -53,7 +56,6 @@ QtObject:
   type Service* = ref object of QObject
     events: EventEmitter
     threadpool: ThreadPool
-    rpcCounter: int
     oldKeyCardService: old_keycard_service.Service
 
   proc delete*(self: Service) =
@@ -64,7 +66,6 @@ QtObject:
     result.QObject.setup
     result.events = events
     result.threadpool = threadpool
-    result.rpcCounter = 0
     result.oldKeyCardService = oldKeyCardService
 
   proc initializeRPC(self: Service)
@@ -79,15 +80,11 @@ QtObject:
   proc initializeRPC(self: Service) {.slot.} =
     var response = keycard_go.keycardInitializeRPC()
 
-  proc callRPC(self: Service, methodName: string, params: JsonNode = %*{}): string  =
-    self.rpcCounter += 1
-    return callRPC(self.rpcCounter, methodName, params)
-
   proc start*(self: Service, storageDir: string) =
-    discard self.callRPC("Start", %*{"storageFilePath": storageDir})
+    discard callRPC("Start", %*{"storageFilePath": storageDir})
 
   proc stop*(self: Service) =
-    discard self.callRPC("Stop")
+    discard callRPC("Stop")
   
   proc buildSeedPhrasesFromIndexes*(seedPhraseIndexes: JsonNode): seq[string] =
     var seedPhrase: seq[string]
@@ -97,7 +94,7 @@ QtObject:
 
   proc generateMnemonic*(self: Service, length: int): string =
     try:
-      let response = self.callRPC("GenerateMnemonic", %*{"length": length})
+      let response = callRPC("GenerateMnemonic", %*{"length": length})
       let rpcResponseObj = response.parseJson
       if rpcResponseObj{"error"}.kind != JNull and rpcResponseObj{"error"}.getStr != "":
           let error = Json.decode(rpcResponseObj["error"].getStr, RpcError)
@@ -111,13 +108,11 @@ QtObject:
       error "error generating mnemonic", err=e.msg
 
   proc loadMnemonic*(self: Service, mnemonic: string) =
-    self.rpcCounter += 1
     let arg = AsyncLoadMnemonicArg(
       tptr: asyncLoadMnemonicTask,
       vptr: cast[uint](self.vptr),
       slot: "onAsyncLoadMnemonicResponse",
       mnemonic: mnemonic,
-      rpcCounter: self.rpcCounter,
     )
     self.threadpool.start(arg)
     
@@ -139,13 +134,11 @@ QtObject:
       self.events.emit(SIGNAL_KEYCARD_LOAD_MNEMONIC_FAILURE, KeycardErrorArg(error: e.msg))
 
   proc asyncAuthorize*(self: Service, pin: string) =
-    self.rpcCounter += 1
     let arg = AsyncAuthorizeArg(
       tptr: asyncAuthorizeTask,
       vptr: cast[uint](self.vptr),
       slot: "onAsyncAuthorizeResponse",
       pin: pin,
-      rpcCounter: self.rpcCounter,
     )
     self.threadpool.start(arg)
 
@@ -177,14 +170,12 @@ QtObject:
       error "error receiving a keycard signal", err=e.msg, data = signal
 
   proc initialize*(self: Service, pin: string, puk: string) =
-    self.rpcCounter += 1
     let arg = AsyncInitializeTaskArg(
       tptr: asyncInitializeTask,
       vptr: cast[uint](self.vptr),
       slot: "onAsyncInitializeResponse",
       pin: pin,
       puk: puk,
-      rpcCounter: self.rpcCounter,
     )
     self.threadpool.start(arg)
 
@@ -209,12 +200,10 @@ QtObject:
       result = result & $rand(0 .. 9)
 
   proc asyncExportRecoverKeys*(self: Service) =
-    self.rpcCounter += 1
     let arg = AsyncExportRecoverKeysArg(
       tptr: asyncExportRecoverKeysTask,
       vptr: cast[uint](self.vptr),
       slot: "onAsyncExportRecoverKeys",
-      rpcCounter: self.rpcCounter,
     )
     self.threadpool.start(arg)
 
@@ -237,12 +226,10 @@ QtObject:
       self.events.emit(SIGNAL_KEYCARD_EXPORT_RESTORE_KEYS_FAILURE, KeycardErrorArg(error: e.msg))
 
   proc asyncExportLoginKeys*(self: Service) =
-    self.rpcCounter += 1
     let arg = AsyncExportLoginKeysArg(
       tptr: asyncExportLoginKeysTask,
       vptr: cast[uint](self.vptr),
       slot: "onAsyncExportLoginKeys",
-      rpcCounter: self.rpcCounter,
     )
     self.threadpool.start(arg)