chore: bring in nim status-go bindings and nuke vendor

.gitmodules

@@ -87,9 +87,6 @@
 [submodule "vendor/status-go"]
 	path = vendor/status-go
 	url = https://github.com/status-im/status-go
-[submodule "vendor/nim-status-go"]
-	path = vendor/nim-status-go
-	url = https://github.com/status-im/nim-status-go.git
 [submodule "vendor/nim-stint"]
 	path = vendor/nim-stint
 	url = https://github.com/status-im/nim-stint.git

docs/architecture.md

@@ -19,7 +19,7 @@ flowchart LR
     seaqt --> nimqml{{"NimQML"}}
     nimqml --> nim["Middleware (Nim)"]
     nim --> statusgo{{"Backend (status-go)"}}
-    nim --> nimstatusgo{{"nim-status-go"}}
+    nim --> nimstatusgo(["status-go Nim bindings"])
     nimstatusgo --> statusgo
     statusgo --> waku{{"Waku"}}
     statusgo --> providers[["Wallet providers"]]
@@ -38,7 +38,7 @@ flowchart LR
     click nim "https://github.com/status-im/status-app/tree/master/src" "Link to the Nim code"
     click statusgo "https://github.com/status-im/status-go" "Link to the Status-Go repo"
     click waku "https://github.com/waku-org" "Link to the Waku org"
-    click nimstatusgo "https://github.com/status-im/nim-status-go" "Link to nim-status-go repo"
+    click nimstatusgo "https://github.com/status-im/status-app/tree/master/src/status_go.nim" "Link to the status-go Nim bindings"
 ```
 
 ## Standard Nim module

mobile/statusgo_stub/statusgo_stub.cpp

@@ -10,7 +10,7 @@
 // the same symbols and forward them to a separate Android service process via Java.
 //
 // Note: For now, the Java side can be a placeholder. This file focuses on:
-// - providing the symbols required by the Nim glue (nim-status-go wrappers)
+// - providing the symbols required by the Nim glue (src/status_go wrappers)
 // - returning heap-allocated cstrings compatible with status-go's Free()
 //
 // The service-side implementation will be added next (Binder + separate process).

src/status_go.nim

@@ -0,0 +1,421 @@
+# This module (see also `./status_go/impl.nim`) wraps the API supplied by
+# status-go when it is compiled into `libstatus.a|dll|dylib|so`, which must be
+# linked into the final executable.
+
+import ./status_go/impl as go_shim
+
+export SignalCallback
+
+proc hashMessage*(message: string): string =
+  var funcOut = go_shim.hashMessage(message.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc initializeApplication*(paramsJSON: string): string =
+  var funcOut = go_shim.initializeApplication(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc toggleCentralizedMetrics*(paramsJSON: string): string =
+  var funcOut = go_shim.toggleCentralizedMetrics(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc addCentralizedMetric*(paramsJSON: string): string =
+  var funcOut = go_shim.addCentralizedMetric(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc centralizedMetricsInfo*(): string =
+  var funcOut = go_shim.centralizedMetricsInfo()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc createAccountFromMnemonicAndDeriveAccountsForPaths*(paramsJSON: string): string =
+  var funcOut = go_shim.createAccountFromMnemonicAndDeriveAccountsForPaths(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc deriveAccountsPublicInfoFromExtendedPublicKeyForPaths*(paramsJSON: string): string =
+  var funcOut = go_shim.deriveAccountsPublicInfoFromExtendedPublicKeyForPaths(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc deriveExtendedPublicKeyAtPath*(paramsJSON: string): string =
+  var funcOut = go_shim.deriveExtendedPublicKeyAtPath(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc convertURCryptoHDKeyToXPub*(ur: string): string =
+  var funcOut = go_shim.convertURCryptoHDKeyToXPub(ur.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc createAccountFromPrivateKey*(paramsJSON: string): string =
+  var funcOut = go_shim.createAccountFromPrivateKey(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc multiAccountImportPrivateKey*(paramsJSON: string): string =
+  var funcOut = go_shim.multiAccountImportPrivateKey(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc multiAccountDeriveAddresses*(paramsJSON: string): string =
+  var funcOut = go_shim.multiAccountDeriveAddresses(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc deleteMultiAccount*(keyUID: string, keyStoreDir: string): string =
+  var funcOut = go_shim.deleteMultiAccount(keyUID.cstring, keyStoreDir.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc callRPC*(inputJSON: string): string =
+  var funcOut = go_shim.callRPC(inputJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc callPrivateRPC*(inputJSON: string): string =
+  var funcOut = go_shim.callPrivateRPC(inputJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc addPeer*(peer: string): string =
+  var funcOut = go_shim.addPeer(peer.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc setSignalEventCallback*(callback: SignalCallback) =
+  go_shim.setSignalEventCallback(callback)
+
+proc sendTransaction*(jsonArgs: string, password: string): string =
+  var funcOut = go_shim.sendTransaction(jsonArgs.cstring, password.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc sendTransactionWithChainId*(chainId: int, jsonArgs: string, password: string): string =
+  var funcOut = go_shim.sendTransactionWithChainId(chainId.cint, jsonArgs.cstring, password.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc generateAlias*(pk: string): string =
+  var funcOut = go_shim.generateAlias(pk)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc isAlias*(value: string): string =
+  var funcOut = go_shim.isAlias(value)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc identicon*(pk: string): string =
+  var funcOut = go_shim.identicon(pk)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc emojiHash*(pk: string): string =
+  var funcOut = go_shim.emojiHash(pk)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc colorHash*(pk: string): string =
+  var funcOut = go_shim.colorHash(pk)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc colorID*(pk: string): string =
+  var funcOut = go_shim.colorID(pk)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc login*(accountData: string, password: string): string =
+  var funcOut = go_shim.login(accountData.cstring, password.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc logout*(): string =
+  var funcOut = go_shim.logout()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc changeDatabasePasswordV2*(paramsJSON: string): string =
+  var funcOut = go_shim.changeDatabasePasswordV2(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc validateMnemonic*(mnemonic: string): string =
+  var funcOut = go_shim.validateMnemonic(mnemonic.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getRandomMnemonic*(): string =
+  var funcOut = go_shim.getRandomMnemonic()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc hashTransaction*(txArgsJSON: string): string =
+  var funcOut = go_shim.hashTransaction(txArgsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc extractGroupMembershipSignatures*(signaturePairsStr: string): string =
+  var funcOut = go_shim.extractGroupMembershipSignatures(signaturePairsStr.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc connectionChange*(typ: string, expensive: string) =
+  go_shim.connectionChange(typ.cstring, expensive.cstring)
+
+proc multiformatSerializePublicKey*(key: string, outBase: string): string =
+  var funcOut = go_shim.multiformatSerializePublicKey(key.cstring, outBase.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc multiformatDeserializePublicKey*(key: string, outBase: string): string =
+  var funcOut = go_shim.multiformatDeserializePublicKey(key.cstring, outBase.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc decompressPublicKey*(key: string): string =
+  var funcOut = go_shim.decompressPublicKey(key.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc compressPublicKey*(key: string): string =
+  var funcOut = go_shim.compressPublicKey(key.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc validateNodeConfig*(configJSON: string): string =
+  var funcOut = go_shim.validateNodeConfig(configJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc convertToKeycardAccount*(accountData: string, settingsJSON: string, keycardUid: string, password: string, newPassword: string): string =
+  var funcOut = go_shim.convertToKeycardAccount(accountData.cstring, settingsJSON.cstring, keycardUid.cstring, password.cstring, newPassword.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc convertToRegularAccount*(mnemonic: string, currPassword: string, newPassword: string): string =
+  var funcOut = go_shim.convertToRegularAccount(mnemonic.cstring, currPassword.cstring, newPassword.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc recover*(rpcParams: string): string =
+  var funcOut = go_shim.recover(rpcParams.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc writeHeapProfile*(dataDir: string): string =
+  var funcOut = go_shim.writeHeapProfile(dataDir.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc hashTypedData*(data: string): string =
+  var funcOut = go_shim.hashTypedData(data.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc hashTypedDataV4*(data: string): string =
+  var funcOut = go_shim.hashTypedDataV4(data.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc resetChainData*(): string =
+  var funcOut = go_shim.resetChainData()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc signMessage*(rpcParams: string): string =
+  var funcOut = go_shim.signMessage(rpcParams.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc signTypedData*(data: string, address: string, password: string): string =
+  var funcOut = go_shim.signTypedData(data.cstring, address.cstring, password.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getNodesFromContract*(rpcEndpoint: string, contractAddress: string): string =
+  var funcOut = go_shim.getNodesFromContract(rpcEndpoint.cstring, contractAddress.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc exportNodeLogs*(): string =
+  var funcOut = go_shim.exportNodeLogs()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc chaosModeUpdate*(on: int): string =
+  var funcOut = go_shim.chaosModeUpdate(on.cint)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc signHash*(hexEncodedHash: string): string =
+  var funcOut = go_shim.signHash(hexEncodedHash.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc sendTransactionWithSignature*(txtArgsJSON: string, sigString: string): string =
+  var funcOut = go_shim.sendTransactionWithSignature(txtArgsJSON.cstring, sigString.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc appStateChange*(state: string) =
+  go_shim.appStateChange(state.cstring)
+
+proc signGroupMembership*(content: string): string =
+  var funcOut = go_shim.signGroupMembership(content.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc multiAccountStoreAccount*(paramsJSON: string): string =
+  var funcOut = go_shim.multiAccountStoreAccount(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc multiAccountLoadAccount*(paramsJSON: string): string =
+  var funcOut = go_shim.multiAccountLoadAccount(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc multiAccountGenerate*(paramsJSON: string): string =
+  var funcOut = go_shim.multiAccountGenerate(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc multiAccountReset*(): string =
+  var funcOut = go_shim.multiAccountReset()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc migrateKeyStoreDir*(accountData: string, password: string, oldKeystoreDir: string, multiaccountKeystoreDir: string): string =
+  var funcOut = go_shim.migrateKeyStoreDir(accountData.cstring, password.cstring, oldKeystoreDir.cstring, multiaccountKeystoreDir.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc startWallet*(watchNewBlocks: bool): string =
+  var funcOut = go_shim.startWallet(watchNewBlocks)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc stopWallet*(): string =
+  var funcOut = go_shim.stopWallet()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc startLocalNotifications*(): string =
+  var funcOut = go_shim.startLocalNotifications()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc stopLocalNotifications*(): string =
+  var funcOut = go_shim.stopLocalNotifications()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getNodeConfig*(): string =
+  var funcOut = go_shim.getNodeConfig()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc imageServerTLSCert*(): string =
+  var funcOut = go_shim.imageServerTLSCert()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getPasswordStrength*(paramsJSON: string): string =
+  var funcOut = go_shim.getPasswordStrength(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getPasswordStrengthScore*(paramsJSON: string): string =
+  var funcOut = go_shim.getPasswordStrengthScore(paramsJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc switchFleet*(newFleet: string, configJSON: string): string =
+  var funcOut = go_shim.switchFleet(newFleet.cstring, configJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc generateImages*(imagePath: string, aX: int, aY: int, bX: int, bY: int): string =
+  var funcOut = go_shim.generateImages(imagePath.cstring, aX.cint, aY.cint, bX.cint, bY.cint)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getConnectionStringForBeingBootstrapped*(configJSON: string): string =
+  var funcOut = go_shim.getConnectionStringForBeingBootstrapped(configJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getConnectionStringForBootstrappingAnotherDevice*(configJSON: string): string =
+  var funcOut = go_shim.getConnectionStringForBootstrappingAnotherDevice(configJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc inputConnectionStringForBootstrapping*(connectionString: string, configJSON: string): string =
+  var funcOut = go_shim.inputConnectionStringForBootstrapping(connectionString.cstring, configJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc validateConnectionString*(connectionString: string): string =
+  var funcOut = go_shim.validateConnectionString(connectionString.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getConnectionStringForExportingKeypairsKeystores*(configJSON: string): string =
+  var funcOut = go_shim.getConnectionStringForExportingKeypairsKeystores(configJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc inputConnectionStringForImportingKeypairsKeystores*(connectionString: string, configJSON: string): string =
+  var funcOut = go_shim.inputConnectionStringForImportingKeypairsKeystores(connectionString.cstring, configJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc loginAccount*(requestJson: string): string =
+  var funcOut = go_shim.loginAccount(requestJson.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc createAccountAndLogin*(requestJSON: string): string =
+  var funcOut = go_shim.createAccountAndLogin(requestJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc restoreAccountAndLogin*(requestJSON: string): string =
+  var funcOut = go_shim.restoreAccountAndLogin(requestJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc deleteMultiaccount*(requestJSON: string): string =
+  var funcOut = go_shim.deleteMultiaccount(requestJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc performLocalBackup*(): string =
+  var funcOut = go_shim.performLocalBackup()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc loadLocalBackup*(filePath: string): string =
+  var funcOut = go_shim.loadLocalBackup(filePath)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc connectionChange*(requestJSON: string): string =
+  var funcOut = go_shim.connectionChange(requestJSON.cstring)
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc getActiveAccount*(): string =
+  var funcOut = go_shim.getActiveAccount()
+  defer: go_shim.free(funcOut)
+  return $funcOut
+
+proc keyUID*(): string =
+  var funcOut = go_shim.keyUID()
+  defer: go_shim.free(funcOut)
+  return $funcOut

src/status_go/impl.nim

@@ -0,0 +1,179 @@
+# go functions do not raise nim exceptions and do not interact with the Nim gc
+{.push raises: [], gcsafe.}
+
+type SignalCallback* = proc(signal: cstring): void {.cdecl.}
+
+# All procs start with lowercase because the compiler will also need to import
+# status-go, and it will complain of duplication of function names
+
+proc hashMessage*(message: cstring): cstring {.importc: "HashMessage".}
+
+proc initializeApplication*(paramsJSON: cstring): cstring {.importc: "InitializeApplication".}
+
+proc toggleCentralizedMetrics*(paramsJSON: cstring): cstring {.importc: "ToggleCentralizedMetrics".}
+
+proc addCentralizedMetric*(paramsJSON: cstring): cstring {.importc: "AddCentralizedMetric".}
+
+proc centralizedMetricsInfo*(): cstring {.importc: "CentralizedMetricsInfo".}
+
+proc createAccountFromMnemonicAndDeriveAccountsForPaths*(paramsJSON: cstring): cstring {.importc: "CreateAccountFromMnemonicAndDeriveAccountsForPaths".}
+
+proc deriveAccountsPublicInfoFromExtendedPublicKeyForPaths*(paramsJSON: cstring): cstring {.importc: "DeriveAccountsPublicInfoFromExtendedPublicKeyForPaths".}
+
+proc deriveExtendedPublicKeyAtPath*(paramsJSON: cstring): cstring {.importc: "DeriveExtendedPublicKeyAtPath".}
+
+proc convertURCryptoHDKeyToXPub*(ur: cstring): cstring {.importc: "ConvertURCryptoHDKeyToXPub".}
+
+proc createAccountFromPrivateKey*(paramsJSON: cstring): cstring {.importc: "CreateAccountFromPrivateKey".}
+
+proc multiAccountImportPrivateKey*(paramsJSON: cstring): cstring {.importc: "MultiAccountImportPrivateKey".}
+
+proc multiAccountDeriveAddresses*(paramsJSON: cstring): cstring {.importc: "MultiAccountDeriveAddresses".}
+
+proc deleteMultiAccount*(keyUID: cstring, keyStoreDir: cstring): cstring {.importc: "DeleteMultiaccount".}
+
+proc callRPC*(inputJSON: cstring): cstring {.importc: "CallRPC".}
+
+proc callPrivateRPC*(inputJSON: cstring): cstring {.importc: "CallPrivateRPC".}
+
+proc addPeer*(peer: cstring): cstring {.importc: "AddPeer".}
+
+proc setSignalEventCallback*(callback: SignalCallback) {.importc: "SetSignalEventCallback".}
+
+proc sendTransaction*(jsonArgs: cstring, password: cstring): cstring {.importc: "SendTransaction".}
+
+proc sendTransactionWithChainId*(chainId: cint, jsonArgs: cstring, password: cstring): cstring {.importc: "SendTransactionWithChainID".}
+
+proc generateAlias*(pk: cstring): cstring {.importc: "GenerateAlias".}
+
+proc isAlias*(value: cstring): cstring {.importc: "IsAlias".}
+
+proc identicon*(pk: cstring): cstring {.importc: "Identicon".}
+
+proc emojiHash*(pk: cstring): cstring {.importc: "EmojiHash".}
+
+proc colorHash*(pk: cstring): cstring {.importc: "ColorHash".}
+
+proc colorID*(pk: cstring): cstring {.importc: "ColorID".}
+
+proc login*(accountData: cstring, password: cstring): cstring {.importc: "Login".}
+
+proc logout*(): cstring {.importc: "Logout".}
+
+proc changeDatabasePasswordV2*(paramsJSON: cstring): cstring {.importc: "ChangeDatabasePasswordV2".}
+
+proc validateMnemonic*(mnemonic: cstring): cstring {.importc: "ValidateMnemonic".}
+
+proc getRandomMnemonic*(): cstring {.importc: "GetRandomMnemonic".}
+
+proc hashTransaction*(txArgsJSON: cstring): cstring {.importc: "HashTransaction".}
+
+proc extractGroupMembershipSignatures*(signaturePairsStr: cstring): cstring {.importc: "ExtractGroupMembershipSignatures".}
+
+proc connectionChange*(typ: cstring, expensive: cstring) {.importc: "ConnectionChange".}
+
+proc multiformatSerializePublicKey*(key: cstring, outBase: cstring): cstring {.importc: "MultiformatSerializePublicKey".}
+
+proc multiformatDeserializePublicKey*(key: cstring, outBase: cstring): cstring {.importc: "MultiformatDeserializePublicKey".}
+
+proc decompressPublicKey*(key: cstring): cstring {.importc: "DecompressPublicKey".}
+
+proc compressPublicKey*(key: cstring): cstring {.importc: "CompressPublicKey".}
+
+proc validateNodeConfig*(configJSON: cstring): cstring {.importc: "ValidateNodeConfig".}
+
+proc loginWithKeycard*(accountData: cstring, password: cstring, keyHex: cstring, confNode: cstring): cstring {.importc: "LoginWithKeycard".}
+
+func convertToKeycardAccount*(accountData: cstring, settingsJSON: cstring, keycardUid: cstring, password: cstring, newPassword: cstring): cstring {.importc: "ConvertToKeycardAccount".}
+
+func convertToRegularAccount*(mnemonic: cstring, currPassword: cstring, newPassword: cstring): cstring {.importc: "ConvertToRegularAccount".}
+
+proc recover*(rpcParams: cstring): cstring {.importc: "Recover".}
+
+proc writeHeapProfile*(dataDir: cstring): cstring {.importc: "WriteHeapProfile".}
+
+proc hashTypedData*(data: cstring): cstring {.importc: "HashTypedData".}
+
+proc hashTypedDataV4*(data: cstring): cstring {.importc: "HashTypedDataV4".}
+
+proc resetChainData*(): cstring {.importc: "ResetChainData".}
+
+proc signMessage*(rpcParams: cstring): cstring {.importc: "SignMessage".}
+
+proc signTypedData*(data: cstring, address: cstring, password: cstring): cstring {.importc: "SignTypedData".}
+
+proc getNodesFromContract*(rpcEndpoint: cstring, contractAddress: cstring): cstring {.importc: "GetNodesFromContract".}
+
+proc exportNodeLogs*(): cstring {.importc: "ExportNodeLogs".}
+
+proc chaosModeUpdate*(on: cint): cstring {.importc: "ChaosModeUpdate".}
+
+proc signHash*(hexEncodedHash: cstring): cstring {.importc: "SignHash".}
+
+proc sendTransactionWithSignature*(txtArgsJSON: cstring, sigString: cstring): cstring {.importc: "SendTransactionWithSignature".}
+
+proc appStateChange*(state: cstring) {.importc: "AppStateChange".}
+
+proc signGroupMembership*(content: cstring): cstring {.importc: "SignGroupMembership".}
+
+proc multiAccountStoreAccount*(paramsJSON: cstring): cstring {.importc: "MultiAccountStoreAccount".}
+
+proc multiAccountLoadAccount*(paramsJSON: cstring): cstring {.importc: "MultiAccountLoadAccount".}
+
+proc multiAccountGenerate*(paramsJSON: cstring): cstring {.importc: "MultiAccountGenerate".}
+
+proc multiAccountReset*(): cstring {.importc: "MultiAccountReset".}
+
+proc migrateKeyStoreDir*(accountData: cstring, password: cstring, oldKeystoreDir: cstring, multiaccountKeystoreDir: cstring): cstring {.importc: "MigrateKeyStoreDir".}
+
+proc startWallet*(watchNewBlocks: bool): cstring {.importc: "StartWallet".}
+
+proc stopWallet*(): cstring {.importc: "StopWallet".}
+
+proc startLocalNotifications*(): cstring {.importc: "StartLocalNotifications".}
+
+proc stopLocalNotifications*(): cstring {.importc: "StopLocalNotifications".}
+
+proc getNodeConfig*(): cstring {.importc: "GetNodeConfig".}
+
+proc free*(param: pointer) {.importc: "Free".}
+
+proc imageServerTLSCert*(): cstring {.importc: "ImageServerTLSCert".}
+
+proc getPasswordStrength*(paramsJSON: cstring): cstring {.importc: "GetPasswordStrength".}
+
+proc getPasswordStrengthScore*(paramsJSON: cstring): cstring {.importc: "GetPasswordStrengthScore".}
+
+proc switchFleet*(newFleet: cstring, configJSON: cstring): cstring{.importc: "SwitchFleet".}
+
+proc generateImages*(imagePath: cstring, aX: cint, aY: cint, bX: cint, bY: cint): cstring {.importc: "GenerateImages".}
+
+proc getConnectionStringForBeingBootstrapped*(configJSON: cstring) : cstring {.importc: "GetConnectionStringForBeingBootstrapped".}
+
+proc getConnectionStringForBootstrappingAnotherDevice*(configJSON: cstring) : cstring {.importc: "GetConnectionStringForBootstrappingAnotherDevice".}
+
+proc inputConnectionStringForBootstrapping*(connectionString: cstring, configJSON: cstring) : cstring {.importc: "InputConnectionStringForBootstrapping".}
+
+proc validateConnectionString*(connectionString: cstring) : cstring {.importc: "ValidateConnectionString".}
+
+proc getConnectionStringForExportingKeypairsKeystores*(configJSON: cstring) : cstring {.importc: "GetConnectionStringForExportingKeypairsKeystores".}
+
+proc inputConnectionStringForImportingKeypairsKeystores*(connectionString: cstring, configJSON: cstring) : cstring {.importc: "InputConnectionStringForImportingKeypairsKeystores".}
+
+proc loginAccount*(requestJSON: cstring): cstring {.importc: "LoginAccount".}
+
+proc createAccountAndLogin*(requestJSON: cstring): cstring {.importc: "CreateAccountAndLogin".}
+
+proc restoreAccountAndLogin*(requestJSON: cstring): cstring {.importc: "RestoreAccountAndLogin".}
+
+proc deleteMultiaccount*(requestJSON: cstring): cstring {.importc: "DeleteMultiaccount".}
+
+proc performLocalBackup*(): cstring {.importc: "PerformLocalBackup".}
+
+proc loadLocalBackup*(filePath: cstring): cstring {.importc: "LoadLocalBackup".}
+
+proc connectionChange*(requestJSON: cstring): cstring {.importc: "ConnectionChange".}
+
+proc getActiveAccount*(): cstring {.importc: "GetActiveAccount".}
+
+proc keyUID*(): cstring {.importc: "KeyUID".}

test/contract/test_wakuext_binding.py

@@ -88,6 +88,7 @@ _UNRESOLVED_ALLOWLIST: set[tuple[str, str]] = {
     ("src/backend/core.nim", "inputJSON"),
     ("src/backend/core.nim", "$inputJSON"),
     ("src/backend/core.nim", "methodName"),
+    ("src/status_go.nim", "inputJSON.cstring"),
 }
 
 # Call sites that name a method the shipped status-go genuinely does not