refactor: modularise network manager

modules/react-native-status/android/src/main/java/im/status/ethereum/module/AccountManager.java

@@ -0,0 +1,402 @@
+package im.status.ethereum.module;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import statusgo.Statusgo;
+import android.net.Uri;
+import android.os.Environment;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+import org.json.JSONObject;
+import org.json.JSONException;
+import android.util.Log;
+import android.content.Context;
+import android.app.Activity;
+
+public class AccountManager extends ReactContextBaseJavaModule {
+    private static final String TAG = "AccountManager";
+    private static final String gethLogFileName = "geth.log";
+    private ReactApplicationContext reactContext;
+
+    private Utils utils;
+    private LogManager logManager;
+
+    public AccountManager(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.utils = new Utils(reactContext);
+        this.logManager = new LogManager(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return "AccountManager";
+    }
+
+    private String getTestnetDataDir(final String absRootDirPath) {
+        return this.utils.pathCombine(absRootDirPath, "ethereum/testnet");
+    }
+
+    @ReactMethod
+    public void createAccountAndLogin(final String createAccountRequest) {
+        Log.d(TAG, "createAccountAndLogin");
+        String result = Statusgo.createAccountAndLogin(createAccountRequest);
+        if (result.startsWith("{\"error\":\"\"")) {
+            Log.d(TAG, "createAccountAndLogin success: " + result);
+            Log.d(TAG, "Geth node started");
+        } else {
+            Log.e(TAG, "createAccountAndLogin failed: " + result);
+        }
+    }
+
+    @ReactMethod
+    public void restoreAccountAndLogin(final String restoreAccountRequest) {
+        Log.d(TAG, "restoreAccountAndLogin");
+        String result = Statusgo.restoreAccountAndLogin(restoreAccountRequest);
+        if (result.startsWith("{\"error\":\"\"")) {
+            Log.d(TAG, "restoreAccountAndLogin success: " + result);
+            Log.d(TAG, "Geth node started");
+        } else {
+            Log.e(TAG, "restoreAccountAndLogin failed: " + result);
+        }
+    }
+
+    private String updateConfig(final String jsonConfigString, final String absRootDirPath, final String keystoreDirPath) throws JSONException {
+        final JSONObject jsonConfig = new JSONObject(jsonConfigString);
+        // retrieve parameters from app config, that will be applied onto the Go-side config later on
+        final String dataDirPath = jsonConfig.getString("DataDir");
+        final Boolean logEnabled = jsonConfig.getBoolean("LogEnabled");
+        final Context context = this.getReactApplicationContext();
+        final File gethLogFile = logEnabled ? this.logManager.prepareLogsFile(context) : null;
+        String gethLogDirPath = null;
+        if (gethLogFile != null) {
+            gethLogDirPath = gethLogFile.getParent();
+        }
+
+        Log.d(TAG, "log dir: " + gethLogDirPath + " log name: " + gethLogFileName);
+
+        jsonConfig.put("DataDir", dataDirPath);
+        jsonConfig.put("KeyStoreDir", keystoreDirPath);
+        jsonConfig.put("LogDir", gethLogDirPath);
+        jsonConfig.put("LogFile", gethLogFileName);
+
+        return jsonConfig.toString();
+    }
+
+    private static void prettyPrintConfig(final String config) {
+        Log.d(TAG, "startNode() with config (see below)");
+        String configOutput = config;
+        final int maxOutputLen = 4000;
+        Log.d(TAG, "********************** NODE CONFIG ****************************");
+        while (!configOutput.isEmpty()) {
+            Log.d(TAG, "Node config:" + configOutput.substring(0, Math.min(maxOutputLen, configOutput.length())));
+            if (configOutput.length() > maxOutputLen) {
+                configOutput = configOutput.substring(maxOutputLen);
+            } else {
+                break;
+            }
+        }
+        Log.d(TAG, "******************* ENDOF NODE CONFIG *************************");
+    }
+
+    private void copyDirectory(File sourceLocation, File targetLocation) throws IOException {
+        if (sourceLocation.isDirectory()) {
+            if (!targetLocation.exists() && !targetLocation.mkdirs()) {
+                throw new IOException("Cannot create dir " + targetLocation.getAbsolutePath());
+            }
+
+            String[] children = sourceLocation.list();
+            for (int i = 0; i < children.length; i++) {
+                copyDirectory(new File(sourceLocation, children[i]), new File(targetLocation, children[i]));
+            }
+        } else {
+            File directory = targetLocation.getParentFile();
+            if (directory != null && !directory.exists() && !directory.mkdirs()) {
+                throw new IOException("Cannot create dir " + directory.getAbsolutePath());
+            }
+
+            InputStream in = new FileInputStream(sourceLocation);
+            OutputStream out = new FileOutputStream(targetLocation);
+
+            byte[] buf = new byte[1024];
+            int len;
+            while ((len = in.read(buf)) > 0) {
+                out.write(buf, 0, len);
+            }
+            in.close();
+            out.close();
+        }
+    }
+
+    private String prepareDirAndUpdateConfig(final String jsonConfigString, final String keyUID) {
+
+        final String absRootDirPath = this.utils.getNoBackupDirectory();
+        final String dataFolder = this.getTestnetDataDir(absRootDirPath);
+        Log.d(TAG, "Starting Geth node in folder: " + dataFolder);
+
+        try {
+            final File newFile = new File(dataFolder);
+            // todo handle error?
+            newFile.mkdir();
+        } catch (Exception e) {
+            Log.e(TAG, "error making folder: " + dataFolder, e);
+        }
+
+        final String ropstenFlagPath = this.utils.pathCombine(absRootDirPath, "ropsten_flag");
+        final File ropstenFlag = new File(ropstenFlagPath);
+        if (!ropstenFlag.exists()) {
+            try {
+                final String chaindDataFolderPath = this.utils.pathCombine(dataFolder, "StatusIM/lightchaindata");
+                final File lightChainFolder = new File(chaindDataFolderPath);
+                if (lightChainFolder.isDirectory()) {
+                    String[] children = lightChainFolder.list();
+                    for (int i = 0; i < children.length; i++) {
+                        new File(lightChainFolder, children[i]).delete();
+                    }
+                }
+                lightChainFolder.delete();
+                ropstenFlag.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        String testnetDataDir = dataFolder;
+        String oldKeystoreDir = this.utils.pathCombine(testnetDataDir, "keystore");
+        String newKeystoreDir = this.utils.pathCombine(absRootDirPath, "keystore");
+        final File oldKeystore = new File(oldKeystoreDir);
+        if (oldKeystore.exists()) {
+            try {
+                final File newKeystore = new File(newKeystoreDir);
+                copyDirectory(oldKeystore, newKeystore);
+
+                if (oldKeystore.isDirectory()) {
+                    String[] children = oldKeystore.list();
+                    for (int i = 0; i < children.length; i++) {
+                        new File(oldKeystoreDir, children[i]).delete();
+                    }
+                }
+                oldKeystore.delete();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        try {
+            final String multiaccountKeystoreDir = this.utils.pathCombine("/keystore", keyUID);
+            final String updatedJsonConfigString = this.updateConfig(jsonConfigString, absRootDirPath, multiaccountKeystoreDir);
+
+            prettyPrintConfig(updatedJsonConfigString);
+
+            return updatedJsonConfigString;
+        } catch (JSONException e) {
+            Log.e(TAG, "updateConfig failed: " + e.getMessage());
+            System.exit(1);
+
+            return "";
+        }
+    }
+
+    @ReactMethod
+    public void prepareDirAndUpdateConfig(final String keyUID, final String config, final Callback callback) {
+        Log.d(TAG, "prepareDirAndUpdateConfig");
+        String finalConfig = prepareDirAndUpdateConfig(config, keyUID);
+        callback.invoke(finalConfig);
+    }
+
+    //TODO : maybe nuke since it is not called anywhere in status-mobile code
+    @ReactMethod
+    public void saveAccountAndLogin(final String multiaccountData, final String password, final String settings, final String config, final String accountsData) {
+        try {
+            Log.d(TAG, "saveAccountAndLogin");
+            String finalConfig = prepareDirAndUpdateConfig(config, this.utils.getKeyUID(multiaccountData));
+            String result = Statusgo.saveAccountAndLogin(multiaccountData, password, settings, finalConfig, accountsData);
+            if (result.startsWith("{\"error\":\"\"")) {
+                Log.d(TAG, "saveAccountAndLogin result: " + result);
+                Log.d(TAG, "Geth node started");
+            } else {
+                Log.e(TAG, "saveAccountAndLogin failed: " + result);
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, "JSON conversion failed: " + e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void saveAccountAndLoginWithKeycard(final String multiaccountData, final String password, final String settings, final String config, final String accountsData, final String chatKey) {
+        try {
+            Log.d(TAG, "saveAccountAndLoginWithKeycard");
+            String finalConfig = prepareDirAndUpdateConfig(config, this.utils.getKeyUID(multiaccountData));
+            String result = Statusgo.saveAccountAndLoginWithKeycard(multiaccountData, password, settings, finalConfig, accountsData, chatKey);
+            if (result.startsWith("{\"error\":\"\"")) {
+                Log.d(TAG, "saveAccountAndLoginWithKeycard result: " + result);
+                Log.d(TAG, "Geth node started");
+            } else {
+                Log.e(TAG, "saveAccountAndLoginWithKeycard failed: " + result);
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, "JSON conversion failed: " + e.getMessage());
+        }
+    }
+
+    //TODO : maybe nuke since it is not called anywhere in status-mobile code
+    @ReactMethod
+    public void login(final String accountData, final String password) {
+        Log.d(TAG, "login");
+        this.utils.migrateKeyStoreDir(accountData, password);
+        String result = Statusgo.login(accountData, password);
+        if (result.startsWith("{\"error\":\"\"")) {
+            Log.d(TAG, "Login result: " + result);
+        } else {
+            Log.e(TAG, "Login failed: " + result);
+        }
+    }
+
+    @ReactMethod
+    public void loginWithKeycard(final String accountData, final String password, final String chatKey, final String nodeConfigJSON) {
+        Log.d(TAG, "loginWithKeycard");
+        this.utils.migrateKeyStoreDir(accountData, password);
+        String result = Statusgo.loginWithKeycard(accountData, password, chatKey, nodeConfigJSON);
+        if (result.startsWith("{\"error\":\"\"")) {
+            Log.d(TAG, "LoginWithKeycard result: " + result);
+        } else {
+            Log.e(TAG, "LoginWithKeycard failed: " + result);
+        }
+    }
+
+    @ReactMethod
+    public void loginWithConfig(final String accountData, final String password, final String configJSON) {
+        Log.d(TAG, "loginWithConfig");
+        this.utils.migrateKeyStoreDir(accountData, password);
+        String result = Statusgo.loginWithConfig(accountData, password, configJSON);
+        if (result.startsWith("{\"error\":\"\"")) {
+            Log.d(TAG, "LoginWithConfig result: " + result);
+        } else {
+            Log.e(TAG, "LoginWithConfig failed: " + result);
+        }
+    }
+
+    @ReactMethod
+    public void loginAccount(final String request) {
+        Log.d(TAG, "loginAccount");
+        String result = Statusgo.loginAccount(request);
+        if (result.startsWith("{\"error\":\"\"")) {
+            Log.d(TAG, "loginAccount result: " + result);
+        } else {
+            Log.e(TAG, "loginAccount failed: " + result);
+        }
+    }
+
+    @ReactMethod
+    public void verify(final String address, final String password, final Callback callback) throws JSONException {
+        Activity currentActivity = getCurrentActivity();
+
+        final String absRootDirPath = this.utils.getNoBackupDirectory();
+        final String newKeystoreDir = this.utils.pathCombine(absRootDirPath, "keystore");
+
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.verifyAccountPassword(newKeystoreDir, address, password), callback);
+    }
+
+    @ReactMethod
+    public void verifyDatabasePassword(final String keyUID, final String password, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.verifyDatabasePassword(keyUID, password), callback);
+    }
+
+    //TODO : use this.utils.executeRunnableStatusGoMethod
+    @ReactMethod
+    private void openAccounts(final Callback callback) {
+        Activity currentActivity = getCurrentActivity();
+
+        final String rootDir = this.utils.getNoBackupDirectory();
+        Log.d(TAG, "openAccounts");
+        if (!this.utils.checkAvailability()) {
+            Log.e(TAG, "[openAccounts] Activity doesn't exist, cannot call openAccounts");
+            System.exit(0);
+            return;
+        }
+
+        Log.d(TAG, "[Opening accounts" + rootDir);
+
+        Runnable r = new Runnable() {
+            @Override
+            public void run() {
+                String result = Statusgo.openAccounts(rootDir);
+                callback.invoke(result);
+            }
+        };
+
+        StatusThreadPoolExecutor.getInstance().execute(r);
+    }
+
+    //TODO : use this.utils.executeRunnableStatusGoMethod
+    @ReactMethod
+    public void logout() {
+        Log.d(TAG, "logout");
+        Runnable r = new Runnable() {
+            @Override
+            public void run() {
+                String result = Statusgo.logout();
+                if (result.startsWith("{\"error\":\"\"")) {
+                    Log.d(TAG, "Logout result: " + result);
+                } else {
+                    Log.e(TAG, "Logout failed: " + result);
+                }
+            }
+        };
+
+        StatusThreadPoolExecutor.getInstance().execute(r);
+    }
+
+    @ReactMethod
+    public void multiAccountStoreAccount(final String json, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiAccountStoreAccount(json), callback);
+    }
+
+    @ReactMethod
+    public void multiAccountLoadAccount(final String json, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiAccountLoadAccount(json), callback);
+    }
+    //TODO: maybe nuke this method since this is not called anywhere in status-mobile
+    @ReactMethod
+    public void multiAccountReset(final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiAccountReset(), callback);
+
+    }
+
+    @ReactMethod
+    public void multiAccountDeriveAddresses(final String json, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiAccountDeriveAddresses(json), callback);
+    }
+
+    @ReactMethod
+    public void multiAccountGenerateAndDeriveAddresses(final String json, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiAccountGenerateAndDeriveAddresses(json), callback);
+    }
+
+    @ReactMethod
+    public void multiAccountStoreDerived(final String json, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiAccountStoreDerivedAccounts(json), callback);
+    }
+
+    @ReactMethod
+    public void multiAccountImportMnemonic(final String json, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiAccountImportMnemonic(json), callback);
+    }
+
+    @ReactMethod
+    public void multiAccountImportPrivateKey(final String json, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiAccountImportPrivateKey(json), callback);
+    }
+
+    @ReactMethod
+    public void deleteMultiaccount(final String keyUID, final Callback callback) throws JSONException {
+        final String keyStoreDir = this.utils.getKeyStorePath(keyUID);
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.deleteMultiaccount(keyUID, keyStoreDir), callback);
+    }
+}

modules/react-native-status/android/src/main/java/im/status/ethereum/module/DatabaseManager.java

@@ -0,0 +1,66 @@
+package im.status.ethereum.module;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Callback;
+import statusgo.Statusgo;
+import android.util.Log;
+import java.io.File;
+import android.os.Environment;
+import android.content.Context;
+public class DatabaseManager extends ReactContextBaseJavaModule {
+    private static final String TAG = "DatabaseManager";
+    private ReactApplicationContext reactContext;
+    private static final String exportDBFileName = "export.db";
+    private Utils utils;
+    public DatabaseManager(ReactApplicationContext reactContext) {
+        this.reactContext = reactContext;
+        this.utils = new Utils(reactContext);
+    }
+    @Override
+    public String getName() {
+        return "DatabaseManager";
+    }
+
+    private File getExportDBFile() {
+        final Context context = this.getReactApplicationContext();
+        // Environment.getExternalStoragePublicDirectory doesn't work as expected on Android Q
+        // https://developer.android.com/reference/android/os/Environment#getExternalStoragePublicDirectory(java.lang.String)
+        final File pubDirectory = context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);
+        final File filename = new File(pubDirectory, exportDBFileName);
+
+        return filename;
+    }
+
+    @ReactMethod
+    public void exportUnencryptedDatabase(final String accountData, final String password, final Callback callback) {
+        Log.d(TAG, "login");
+
+        final File newFile = getExportDBFile();
+
+        this.utils.migrateKeyStoreDir(accountData, password);
+        String result = Statusgo.exportUnencryptedDatabase(accountData, password, newFile.getAbsolutePath());
+        if (result.startsWith("{\"error\":\"\"")) {
+            Log.d(TAG, "Login result: " + result);
+        } else {
+            Log.e(TAG, "Login failed: " + result);
+        }
+    }
+
+    @ReactMethod
+    public void importUnencryptedDatabase(final String accountData, final String password) {
+        Log.d(TAG, "importUnencryptedDatabase");
+
+        final File newFile = getExportDBFile();
+
+        this.utils.migrateKeyStoreDir(accountData, password);
+        String result = Statusgo.importUnencryptedDatabase(accountData, password, newFile.getAbsolutePath());
+        if (result.startsWith("{\"error\":\"\"")) {
+            Log.d(TAG, "import result: " + result);
+        } else {
+            Log.e(TAG, "import failed: " + result);
+        }
+    }
+
+}

modules/react-native-status/android/src/main/java/im/status/ethereum/module/EncryptionUtils.java

@@ -0,0 +1,199 @@
+package im.status.ethereum.module;
+
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.Callback;
+import android.util.Log;
+import statusgo.Statusgo;
+import org.json.JSONException;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import android.app.Activity;
+import android.view.WindowManager;
+import android.os.Build;
+import android.view.Window;
+import android.preference.PreferenceManager;
+import android.content.SharedPreferences;
+
+public class EncryptionUtils extends ReactContextBaseJavaModule {
+    private static final String TAG = "EncryptionUtils";
+
+    private ReactApplicationContext reactContext;
+    private Utils utils;
+
+    public EncryptionUtils(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.utils = new Utils(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return "EncryptionUtils";
+    }
+
+    @ReactMethod
+    private void initKeystore(final String keyUID, final Callback callback) throws JSONException {
+        Log.d(TAG, "initKeystore");
+
+        final String commonKeydir = this.utils.pathCombine(this.utils.getNoBackupDirectory(), "/keystore");
+        final String keydir = this.utils.pathCombine(commonKeydir, keyUID);
+
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.initKeystore(keydir), callback);
+    }
+
+    @ReactMethod
+    public void reEncryptDbAndKeystore(final String keyUID, final String password, final String newPassword, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.changeDatabasePassword(keyUID, password, newPassword), callback);
+    }
+
+    @ReactMethod
+    public void convertToKeycardAccount(final String keyUID, final String accountData, final String options, final String keycardUID, final String password,
+                                        final String newPassword, final Callback callback) throws JSONException {
+        final String keyStoreDir = this.utils.getKeyStorePath(keyUID);
+        this.utils.executeRunnableStatusGoMethod(() -> {
+            Statusgo.initKeystore(keyStoreDir);
+            return Statusgo.convertToKeycardAccount(accountData, options, keycardUID, password, newPassword);
+        }, callback);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String encodeTransfer(final String to, final String value) {
+        return Statusgo.encodeTransfer(to, value);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String encodeFunctionCall(final String method, final String paramsJSON) {
+        return Statusgo.encodeFunctionCall(method, paramsJSON);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String decodeParameters(final String decodeParamJSON) {
+        return Statusgo.decodeParameters(decodeParamJSON);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String hexToNumber(final String hex) {
+        return Statusgo.hexToNumber(hex);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String numberToHex(final String numString) {
+        return Statusgo.numberToHex(numString);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String sha3(final String str) {
+        return Statusgo.sha3(str);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String utf8ToHex(final String str) {
+        return Statusgo.utf8ToHex(str);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String hexToUtf8(final String str) {
+        return Statusgo.hexToUtf8(str);
+    }
+
+    @ReactMethod
+    public void setBlankPreviewFlag(final Boolean blankPreview) {
+        final SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this.reactContext);
+        sharedPrefs.edit().putBoolean("BLANK_PREVIEW", blankPreview).commit();
+        setSecureFlag();
+    }
+
+    private void setSecureFlag() {
+        final SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this.reactContext);
+        final boolean setSecure = sharedPrefs.getBoolean("BLANK_PREVIEW", true);
+        final Activity activity = this.reactContext.getCurrentActivity();
+        if (activity != null) {
+            activity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    final Window window = activity.getWindow();
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH && setSecure) {
+                        window.addFlags(WindowManager.LayoutParams.FLAG_SECURE);
+                    } else {
+                        window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE);
+                    }
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void hashTransaction(final String txArgsJSON, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.hashTransaction(txArgsJSON), callback);
+    }
+
+    @ReactMethod
+    public void hashMessage(final String message, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.hashMessage(message), callback);
+    }
+
+    @ReactMethod
+    public void multiformatSerializePublicKey(final String multiCodecKey, final String base58btc, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiformatSerializePublicKey(multiCodecKey,base58btc), callback);
+    }
+
+    @ReactMethod
+    public void multiformatDeserializePublicKey(final String multiCodecKey, final String base58btc, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.multiformatDeserializePublicKey(multiCodecKey,base58btc), callback);
+    }
+
+    @ReactMethod
+    public void compressPublicKey(final String multiCodecKey, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.compressPublicKey(multiCodecKey), callback);
+    }
+
+    @ReactMethod
+    public void decompressPublicKey(final String multiCodecKey, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.decompressPublicKey(multiCodecKey), callback);
+    }
+
+    @ReactMethod
+    public void deserializeAndCompressKey(final String desktopKey, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.deserializeAndCompressKey(desktopKey), callback);
+    }
+
+    @ReactMethod
+    public void hashTypedData(final String data, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.hashTypedData(data), callback);
+    }
+
+    @ReactMethod
+    public void hashTypedDataV4(final String data, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.hashTypedDataV4(data), callback);
+    }
+
+    @ReactMethod
+    public void signMessage(final String rpcParams, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.signMessage(rpcParams), callback);
+    }
+
+    @ReactMethod
+    public void signTypedData(final String data, final String account, final String password, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.signTypedData(data, account, password), callback);
+    }
+
+    @ReactMethod
+    public void signTypedDataV4(final String data, final String account, final String password, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.signTypedDataV4(data, account, password), callback);
+
+    }
+
+    @ReactMethod
+    public void extractGroupMembershipSignatures(final String signaturePairs, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.extractGroupMembershipSignatures(signaturePairs), callback);
+    }
+
+    @ReactMethod
+    public void signGroupMembership(final String content, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.signGroupMembership(content), callback);
+    }
+
+
+}

modules/react-native-status/android/src/main/java/im/status/ethereum/module/LogManager.java

@@ -0,0 +1,228 @@
+package im.status.ethereum.module;
+
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.Callback;
+import java.io.File;
+import java.util.Stack;
+import android.util.Log;
+import android.net.Uri;
+import java.io.OutputStreamWriter;
+import java.io.IOException;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import androidx.core.content.FileProvider;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.util.zip.ZipOutputStream;
+import java.io.FileInputStream;
+import java.util.zip.ZipEntry;
+import org.json.JSONObject;
+import statusgo.Statusgo;
+import android.content.Context;
+import org.json.JSONException;
+public class LogManager extends ReactContextBaseJavaModule {
+    private static final String TAG = "LogManager";
+    private static final String gethLogFileName = "geth.log";
+    private static final String statusLogFileName = "Status.log";
+    private static final String logsZipFileName = "Status-debug-logs.zip";
+    private ReactApplicationContext reactContext;
+    private Utils utils;
+
+    public LogManager(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.utils = new Utils(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return "LogManager";
+    }
+
+    private File getLogsFile() {
+        final File pubDirectory = this.utils.getPublicStorageDirectory();
+        final File logFile = new File(pubDirectory, gethLogFileName);
+
+        return logFile;
+    }
+
+    public File prepareLogsFile(final Context context) {
+        final File logFile = this.utils.getLogsFile();
+
+        try {
+            logFile.setReadable(true);
+            File parent = logFile.getParentFile();
+            if (!parent.canWrite()) {
+                return null;
+            }
+            if (!parent.exists()) {
+                parent.mkdirs();
+            }
+            logFile.createNewFile();
+            logFile.setWritable(true);
+            Log.d(TAG, "Can write " + logFile.canWrite());
+            Uri gethLogUri = Uri.fromFile(logFile);
+
+            String gethLogFilePath = logFile.getAbsolutePath();
+            Log.d(TAG, gethLogFilePath);
+
+            return logFile;
+        } catch (Exception e) {
+            Log.d(TAG, "Can't create geth.log file! " + e.getMessage());
+        }
+
+        return null;
+    }
+
+    private void showErrorMessage(final String message) {
+        final Activity activity = getCurrentActivity();
+
+        new AlertDialog.Builder(activity)
+                .setTitle("Error")
+                .setMessage(message)
+                .setNegativeButton("Exit", new DialogInterface.OnClickListener() {
+                    public void onClick(final DialogInterface dialog, final int id) {
+                        dialog.dismiss();
+                    }
+                }).show();
+    }
+
+    private void dumpAdbLogsTo(final FileOutputStream statusLogStream) throws IOException {
+        final String filter = "logcat -d -b main ReactNativeJS:D StatusModule:D StatusService:D StatusNativeLogs:D *:S";
+        final java.lang.Process p = Runtime.getRuntime().exec(filter);
+        final java.io.BufferedReader in = new java.io.BufferedReader(new java.io.InputStreamReader(p.getInputStream()));
+        final java.io.BufferedWriter out = new java.io.BufferedWriter(new java.io.OutputStreamWriter(statusLogStream));
+        String line;
+        while ((line = in.readLine()) != null) {
+            out.write(line);
+            out.newLine();
+        }
+        out.close();
+        in.close();
+    }
+
+    private Boolean zip(File[] _files, File zipFile, Stack<String> errorList) {
+        final int BUFFER = 0x8000;
+
+        try {
+            BufferedInputStream origin = null;
+            FileOutputStream dest = new FileOutputStream(zipFile);
+            ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(dest));
+            byte data[] = new byte[BUFFER];
+
+            for (int i = 0; i < _files.length; i++) {
+                final File file = _files[i];
+                if (file == null || !file.exists()) {
+                    continue;
+                }
+
+                Log.v("Compress", "Adding: " + file.getAbsolutePath());
+                try {
+                    FileInputStream fi = new FileInputStream(file);
+                    origin = new BufferedInputStream(fi, BUFFER);
+
+                    ZipEntry entry = new ZipEntry(file.getName());
+                    out.putNextEntry(entry);
+                    int count;
+
+                    while ((count = origin.read(data, 0, BUFFER)) != -1) {
+                        out.write(data, 0, count);
+                    }
+                    origin.close();
+                } catch (IOException e) {
+                    Log.e(TAG, e.getMessage());
+                    errorList.push(e.getMessage());
+                }
+            }
+
+            out.close();
+
+            return true;
+        } catch (Exception e) {
+            Log.e(TAG, e.getMessage());
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    @ReactMethod
+    public void sendLogs(final String dbJson, final String jsLogs, final Callback callback) {
+        Log.d(TAG, "sendLogs");
+        if (!this.utils.checkAvailability()) {
+            return;
+        }
+
+        final Context context = this.getReactApplicationContext();
+        final File logsTempDir = new File(context.getCacheDir(), "logs"); // This path needs to be in sync with android/app/src/main/res/xml/file_provider_paths.xml
+        logsTempDir.mkdir();
+
+        final File dbFile = new File(logsTempDir, "db.json");
+        try {
+            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(dbFile));
+            outputStreamWriter.write(dbJson);
+            outputStreamWriter.close();
+        } catch (IOException e) {
+            Log.e(TAG, "File write failed: " + e.toString());
+            showErrorMessage(e.getLocalizedMessage());
+        }
+
+        final File zipFile = new File(logsTempDir, logsZipFileName);
+        final File statusLogFile = new File(logsTempDir, statusLogFileName);
+        final File gethLogFile = getLogsFile();
+
+        try {
+            if (zipFile.exists() || zipFile.createNewFile()) {
+                final long usableSpace = zipFile.getUsableSpace();
+                if (usableSpace < 20 * 1024 * 1024) {
+                    final String message = String.format("Insufficient space available on device (%s) to write logs.\nPlease free up some space.", android.text.format.Formatter.formatShortFileSize(context, usableSpace));
+                    Log.e(TAG, message);
+                    showErrorMessage(message);
+                    return;
+                }
+            }
+
+            dumpAdbLogsTo(new FileOutputStream(statusLogFile));
+
+            final Stack<String> errorList = new Stack<String>();
+            final Boolean zipped = zip(new File[]{dbFile, gethLogFile, statusLogFile}, zipFile, errorList);
+            if (zipped && zipFile.exists()) {
+                zipFile.setReadable(true, false);
+                Uri extUri = FileProvider.getUriForFile(context, context.getPackageName() + ".provider", zipFile);
+                callback.invoke(extUri.toString());
+            } else {
+                Log.d(TAG, "File " + zipFile.getAbsolutePath() + " does not exist");
+            }
+        } catch (Exception e) {
+            Log.e(TAG, e.getMessage());
+            showErrorMessage(e.getLocalizedMessage());
+            e.printStackTrace();
+            return;
+        } finally {
+            dbFile.delete();
+            statusLogFile.delete();
+            zipFile.deleteOnExit();
+        }
+    }
+
+    @ReactMethod
+    public void initLogging(final boolean enabled, final boolean mobileSystem, final String logLevel, final Callback callback) throws JSONException {
+        final JSONObject jsonConfig = new JSONObject();
+        jsonConfig.put("Enabled", enabled);
+        jsonConfig.put("MobileSystem", mobileSystem);
+        jsonConfig.put("Level", logLevel);
+        jsonConfig.put("File", getLogsFile().getAbsolutePath());
+        final String config = jsonConfig.toString();
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.initLogging(config), callback);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String logFileDirectory() {
+        return this.utils.getPublicStorageDirectory().getAbsolutePath();
+    }
+
+
+}

modules/react-native-status/android/src/main/java/im/status/ethereum/module/NetworkManager.java

@@ -0,0 +1,84 @@
+package im.status.ethereum.module;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Callback;
+import org.json.JSONException;
+import statusgo.Statusgo;
+import org.json.JSONObject;
+
+public class NetworkManager extends ReactContextBaseJavaModule {
+    private static final String TAG = "NetworkManager";
+    private ReactApplicationContext reactContext;
+    private Utils utils;
+
+    public NetworkManager(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.utils = new Utils(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return "NetworkManager";
+    }
+
+    @ReactMethod
+    public void addPeer(final String enode, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.addPeer(enode), callback);
+    }
+
+    @ReactMethod
+    public void startSearchForLocalPairingPeers(final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.startSearchForLocalPairingPeers(), callback);
+    }
+
+    @ReactMethod
+    public void getConnectionStringForBootstrappingAnotherDevice(final String configJSON, final Callback callback) throws JSONException {
+        final JSONObject jsonConfig = new JSONObject(configJSON);
+        final JSONObject senderConfig = jsonConfig.getJSONObject("senderConfig");
+        final String keyUID = senderConfig.getString("keyUID");
+        final String keyStorePath = this.utils.getKeyStorePath(keyUID);
+        senderConfig.put("keystorePath", keyStorePath);
+
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.getConnectionStringForBootstrappingAnotherDevice(jsonConfig.toString()), callback);
+    }
+
+    @ReactMethod
+    public void inputConnectionStringForBootstrapping(final String connectionString, final String configJSON, final Callback callback) throws JSONException {
+        final JSONObject jsonConfig = new JSONObject(configJSON);
+        final JSONObject receiverConfig = jsonConfig.getJSONObject("receiverConfig");
+        final String keyStorePath = this.utils.pathCombine(this.utils.getNoBackupDirectory(), "/keystore");
+        receiverConfig.put("keystorePath", keyStorePath);
+        receiverConfig.getJSONObject("nodeConfig").put("rootDataDir", this.utils.getNoBackupDirectory());
+
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.inputConnectionStringForBootstrapping(connectionString, jsonConfig.toString()), callback);
+    }
+
+    @ReactMethod
+    public void sendTransactionWithSignature(final String txArgsJSON, final String signature, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.sendTransactionWithSignature(txArgsJSON, signature), callback);
+    }
+
+    @ReactMethod
+    public void sendTransaction(final String txArgsJSON, final String password, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.sendTransaction(txArgsJSON, password), callback);
+    }
+
+    @ReactMethod
+    public void callRPC(final String payload, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.callRPC(payload), callback);
+    }
+
+    @ReactMethod
+    public void callPrivateRPC(final String payload, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.callPrivateRPC(payload), callback);
+    }
+
+    @ReactMethod
+    public void recover(final String rpcParams, final Callback callback) throws JSONException {
+        this.utils.executeRunnableStatusGoMethod(() -> Statusgo.recover(rpcParams), callback);
+    }
+
+}

modules/react-native-status/android/src/main/java/im/status/ethereum/module/StatusPackage.java

@@ -30,6 +30,13 @@ public class StatusPackage implements ReactPackage {
         List<NativeModule> modules = new ArrayList<>();
 
         modules.add(new StatusModule(reactContext, this.rootedDevice));
+        modules.add(new AccountManager(reactContext));
+        modules.add(new EncryptionUtils(reactContext));
+        modules.add(new DatabaseManager(reactContext));
+        modules.add(new UIHelper(reactContext));
+        modules.add(new LogManager(reactContext));
+        modules.add(new Utils(reactContext));
+        modules.add(new NetworkManager(reactContext));
         modules.add(new RNSelectableTextInputModule(reactContext));
 
         return modules;

modules/react-native-status/android/src/main/java/im/status/ethereum/module/UIHelper.java

@@ -0,0 +1,159 @@
+package im.status.ethereum.module;
+
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import android.app.Activity;
+import android.util.Log;
+import android.os.Build;
+import android.webkit.WebView;
+import android.webkit.CookieManager;
+import android.webkit.CookieSyncManager;
+import android.webkit.WebStorage;
+import android.view.WindowManager;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.UIBlock;
+import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import android.view.inputmethod.InputMethodManager;
+import android.view.View;
+import android.widget.EditText;
+import android.content.Context;
+
+public class UIHelper extends ReactContextBaseJavaModule {
+    private static final String TAG = "UIHelper";
+    private ReactApplicationContext reactContext;
+
+    public UIHelper(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return "UIHelper";
+    }
+
+    //TODO : maybe nuke since it is not called anywhere in status-mobile code
+    @ReactMethod
+    public void setAdjustResize() {
+        Log.d(TAG, "setAdjustResize");
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            return;
+        }
+
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+            }
+        });
+    }
+
+    //TODO : maybe nuke since it is not called anywhere in status-mobile code
+    @ReactMethod
+    public void setAdjustPan() {
+        Log.d(TAG, "setAdjustPan");
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            return;
+        }
+
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void setSoftInputMode(final int mode) {
+        Log.d(TAG, "setSoftInputMode");
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            return;
+        }
+
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                activity.getWindow().setSoftInputMode(mode);
+            }
+        });
+    }
+
+    @SuppressWarnings("deprecation")
+    @ReactMethod
+    public void clearCookies() {
+        Log.d(TAG, "clearCookies");
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            return;
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) {
+            CookieManager.getInstance().removeAllCookies(null);
+            CookieManager.getInstance().flush();
+        } else {
+            CookieSyncManager cookieSyncManager = CookieSyncManager.createInstance(activity);
+            cookieSyncManager.startSync();
+            CookieManager cookieManager = CookieManager.getInstance();
+            cookieManager.removeAllCookie();
+            cookieManager.removeSessionCookie();
+            cookieSyncManager.stopSync();
+            cookieSyncManager.sync();
+        }
+    }
+
+    @ReactMethod
+    public void toggleWebviewDebug(final boolean val) {
+        Log.d(TAG, "toggleWebviewDebug");
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            return;
+        }
+
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                WebView.setWebContentsDebuggingEnabled(val);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void clearStorageAPIs() {
+        Log.d(TAG, "clearStorageAPIs");
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            return;
+        }
+
+        WebStorage storage = WebStorage.getInstance();
+        if (storage != null) {
+            storage.deleteAllData();
+        }
+    }
+
+    @ReactMethod
+    public void resetKeyboardInputCursor(final int reactTagToReset, final int selection) {
+        UIManagerModule uiManager = getReactApplicationContext().getNativeModule(UIManagerModule.class);
+        uiManager.addUIBlock(new UIBlock() {
+            @Override
+            public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+                InputMethodManager imm = (InputMethodManager) getReactApplicationContext().getBaseContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+                if (imm != null) {
+                    View viewToReset = nativeViewHierarchyManager.resolveView(reactTagToReset);
+                    imm.restartInput(viewToReset);
+                    try {
+                        EditText textView = (EditText) viewToReset;
+                        textView.setSelection(selection);
+                    } catch (Exception e) {}
+                }
+            }
+        });
+    }
+
+
+}

modules/react-native-status/android/src/main/java/im/status/ethereum/module/Utils.java

@@ -0,0 +1,155 @@
+package im.status.ethereum.module;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import android.util.Log;
+import java.util.function.Supplier;
+import java.io.File;
+import android.content.Context;
+import android.os.Environment;
+import org.json.JSONObject;
+import org.json.JSONException;
+import statusgo.Statusgo;
+
+public class Utils extends ReactContextBaseJavaModule  {
+    private static final String gethLogFileName = "geth.log";
+
+    private static final String TAG = "Utils";
+    private ReactApplicationContext reactContext;
+
+    public Utils(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return "Utils";
+    }
+    public String getNoBackupDirectory() {
+        return this.getReactApplicationContext().getNoBackupFilesDir().getAbsolutePath();
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String backupDisabledDataDir() {
+        return getNoBackupDirectory();
+    }
+
+    public File getPublicStorageDirectory() {
+        final Context context = this.getReactApplicationContext();
+        // Environment.getExternalStoragePublicDirectory doesn't work as expected on Android Q
+        // https://developer.android.com/reference/android/os/Environment#getExternalStoragePublicDirectory(java.lang.String)
+        return context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);
+    }
+
+    public File getLogsFile() {
+        final File pubDirectory = getPublicStorageDirectory();
+        final File logFile = new File(pubDirectory, gethLogFileName);
+
+        return logFile;
+    }
+
+    public String getKeyUID(final String json) throws JSONException {
+        final JSONObject jsonObj = new JSONObject(json);
+        return jsonObj.getString("key-uid");
+    }
+
+    public String pathCombine(final String path1, final String path2) {
+        // Replace this logic with Paths.get(path1, path2) once API level 26+ becomes the minimum supported API level
+        final File file = new File(path1, path2);
+        return file.getAbsolutePath();
+    }
+
+    public String getKeyStorePath(String keyUID) {
+        final String commonKeydir = pathCombine(getNoBackupDirectory(), "/keystore");
+        final String keydir = pathCombine(commonKeydir, keyUID);
+
+        return keydir;
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String keystoreDir() {
+        final String absRootDirPath = getNoBackupDirectory();
+        return pathCombine(absRootDirPath, "keystore");
+    }
+
+    public void migrateKeyStoreDir(final String accountData, final String password) {
+        try {
+            final String commonKeydir = pathCombine(getNoBackupDirectory(), "/keystore");
+            final String keydir = getKeyStorePath(getKeyUID(accountData));
+            Log.d(TAG, "before migrateKeyStoreDir " + keydir);
+
+            File keydirFile = new File(keydir);
+            if(!keydirFile.exists() || keydirFile.list().length == 0) {
+                Log.d(TAG, "migrateKeyStoreDir");
+                Statusgo.migrateKeyStoreDir(accountData, password, commonKeydir, keydir);
+                Statusgo.initKeystore(keydir);
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, "JSON conversion failed: " + e.getMessage());
+        }
+    }
+
+    public boolean checkAvailability() {
+        // We wait at least 10s for getCurrentActivity to return a value,
+        // otherwise we give up
+        for (int attempts = 0; attempts < 100; attempts++) {
+            if (getCurrentActivity() != null) {
+                return true;
+            }
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException ex) {
+                if (getCurrentActivity() != null) {
+                    return true;
+                }
+                Log.d(TAG, "Activity doesn't exist");
+                return false;
+            }
+        }
+
+        Log.d(TAG, "Activity doesn't exist");
+        return false;
+    }
+
+    public void executeRunnableStatusGoMethod(Supplier<String> method, Callback callback) throws JSONException {
+        if (!checkAvailability()) {
+            callback.invoke(false);
+            return;
+        }
+
+        Runnable runnableTask = () -> {
+            String res = method.get();
+            callback.invoke(res);
+        };
+
+        StatusThreadPoolExecutor.getInstance().execute(runnableTask);
+    }
+
+    @ReactMethod
+    public void validateMnemonic(final String seed, final Callback callback) throws JSONException {
+        executeRunnableStatusGoMethod(() -> Statusgo.validateMnemonic(seed), callback);
+    }
+
+    public Boolean is24Hour() {
+        return android.text.format.DateFormat.is24HourFormat(this.reactContext.getApplicationContext());
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String checkAddressChecksum(final String address) {
+        return Statusgo.checkAddressChecksum(address);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String isAddress(final String address) {
+        return Statusgo.isAddress(address);
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String toChecksumAddress(final String address) {
+        return Statusgo.toChecksumAddress(address);
+    }
+
+}

src/native_module/core.cljs

@@ -11,6 +11,41 @@
   (when (exists? (.-NativeModules react-native))
     (.-Status ^js (.-NativeModules react-native))))
 
+(defn account
+  []
+  (when (exists? (.-NativeModules react-native))
+        (.-AccountManager ^js (.-NativeModules react-native))))
+
+(defn encryption
+  []
+  (when (exists? (.-NativeModules react-native))
+        (.-EncryptionUtils ^js (.-NativeModules react-native))))
+
+(defn database
+  []
+  (when (exists? (.-NativeModules react-native))
+        (.-DatabaseManager ^js (.-NativeModules react-native))))
+
+(defn ui-helper
+  []
+  (when (exists? (.-NativeModules react-native))
+        (.-UIHelper ^js (.-NativeModules react-native))))
+
+(defn log-manager
+  []
+  (when (exists? (.-NativeModules react-native))
+        (.-LogManager ^js (.-NativeModules react-native))))
+
+(defn utils
+  []
+  (when (exists? (.-NativeModules react-native))
+        (.-Utils ^js (.-NativeModules react-native))))
+
+(defn network
+  []
+  (when (exists? (.-NativeModules react-native))
+        (.-NetworkManager ^js (.-NativeModules react-native))))
+
 (defn init
   [handler]
   (.addListener ^js (.-DeviceEventEmitter ^js react-native) "gethEvent" #(handler (.-jsonEvent ^js %))))
@@ -19,23 +54,23 @@
   []
   (log/debug "[native-module] clear-web-data")
   (when (status)
-    (.clearCookies ^js (status))
-    (.clearStorageAPIs ^js (status))))
+    (.clearCookies ^js (ui-helper))
+    (.clearStorageAPIs ^js (ui-helper))))
 
 (defn init-keystore
   [key-uid callback]
   (log/debug "[native-module] init-keystore" key-uid)
-  (.initKeystore ^js (status) key-uid callback))
+  (.initKeystore ^js (encryption) key-uid callback))
 
 (defn open-accounts
   [callback]
   (log/debug "[native-module] open-accounts")
-  (.openAccounts ^js (status) #(callback (types/json->clj %))))
+  (.openAccounts ^js (account) #(callback (types/json->clj %))))
 
 (defn prepare-dir-and-update-config
   [key-uid config callback]
   (log/debug "[native-module] prepare-dir-and-update-config")
-  (.prepareDirAndUpdateConfig ^js (status)
+  (.prepareDirAndUpdateConfig ^js (account)
                               key-uid
                               config
                               #(callback (types/json->clj %))))
@@ -47,7 +82,7 @@
   (init-keystore
    key-uid
    #(.saveAccountAndLoginWithKeycard
-     ^js (status)
+     ^js (account)
      multiaccount-data
      password
      settings
@@ -63,24 +98,24 @@
   (let [config (if config (types/clj->json config) "")]
     (init-keystore
      key-uid
-     #(.loginWithConfig ^js (status) account-data hashed-password config))))
+     #(.loginWithConfig ^js (account) account-data hashed-password config))))
 
 (defn login-account
   "NOTE: beware, the password has to be sha3 hashed"
   [{:keys [keyUid] :as request}]
-  (log/debug "[native-module] loginWithConfig")
+  (log/debug "[native-module] loginAccount")
   (clear-web-data)
   (init-keystore
    keyUid
-   #(.loginAccount ^js (status) (types/clj->json request))))
+   #(.loginAccount ^js (account) (types/clj->json request))))
 
 (defn create-account-and-login
   [request]
-  (.createAccountAndLogin ^js (status) (types/clj->json request)))
+  (.createAccountAndLogin ^js (account) (types/clj->json request)))
 
 (defn restore-account-and-login
   [request]
-  (.restoreAccountAndLogin ^js (status) (types/clj->json request)))
+  (.restoreAccountAndLogin ^js (account) (types/clj->json request)))
 
 (defn export-db
   "NOTE: beware, the password has to be sha3 hashed"
@@ -89,7 +124,7 @@
   (clear-web-data)
   (init-keystore
    key-uid
-   #(.exportUnencryptedDatabase ^js (status) account-data hashed-password callback)))
+   #(.exportUnencryptedDatabase ^js (database) account-data hashed-password callback)))
 
 (defn import-db
   "NOTE: beware, the password has to be sha3 hashed"
@@ -98,13 +133,13 @@
   (clear-web-data)
   (init-keystore
    key-uid
-   #(.importUnencryptedDatabase ^js (status) account-data hashed-password)))
+   #(.importUnencryptedDatabase ^js (database) account-data hashed-password)))
 
 (defn logout
   []
   (log/debug "[native-module] logout")
   (clear-web-data)
-  (.logout ^js (status)))
+  (.logout ^js (account)))
 
 (defn multiaccount-load-account
   "NOTE: beware, the password has to be sha3 hashed
@@ -114,7 +149,7 @@
    from memory"
   [address hashed-password callback]
   (log/debug "[native-module] multiaccount-load-account")
-  (.multiAccountLoadAccount ^js (status)
+  (.multiAccountLoadAccount ^js (account)
                             (types/clj->json {:address  address
                                               :password hashed-password})
                             callback))
@@ -127,7 +162,7 @@
   [account-id paths callback]
   (log/debug "[native-module]  multiaccount-derive-addresses")
   (when (status)
-    (.multiAccountDeriveAddresses ^js (status)
+    (.multiAccountDeriveAddresses ^js (account)
                                   (types/clj->json {:accountID account-id
                                                     :paths     paths})
                                   callback)))
@@ -145,7 +180,7 @@
   (when (status)
     (init-keystore
      key-uid
-     #(.multiAccountStoreAccount ^js (status)
+     #(.multiAccountStoreAccount ^js (account)
                                  (types/clj->json {:accountID account-id
                                                    :password  hashed-password})
                                  callback))))
@@ -158,7 +193,7 @@
              account-id)
   (init-keystore
    key-uid
-   #(.multiAccountStoreDerived ^js (status)
+   #(.multiAccountStoreDerived ^js (account)
                                (types/clj->json {:accountID account-id
                                                  :paths     paths
                                                  :password  hashed-password})
@@ -171,7 +206,7 @@
    to store the key"
   [n mnemonic-length paths callback]
   (log/debug "[native-module]  multiaccount-generate-and-derive-addresses")
-  (.multiAccountGenerateAndDeriveAddresses ^js (status)
+  (.multiAccountGenerateAndDeriveAddresses ^js (account)
                                            (types/clj->json {:n                    n
                                                              :mnemonicPhraseLength mnemonic-length
                                                              :bip39Passphrase      ""
@@ -181,7 +216,7 @@
 (defn multiaccount-import-mnemonic
   [mnemonic password callback]
   (log/debug "[native-module] multiaccount-import-mnemonic")
-  (.multiAccountImportMnemonic ^js (status)
+  (.multiAccountImportMnemonic ^js (account)
                                (types/clj->json {:mnemonicPhrase  mnemonic
                                                  ;;NOTE this is not the multiaccount password
                                                  :Bip39Passphrase password})
@@ -190,7 +225,7 @@
 (defn multiaccount-import-private-key
   [private-key callback]
   (log/debug "[native-module] multiaccount-import-private-key")
-  (.multiAccountImportPrivateKey ^js (status)
+  (.multiAccountImportPrivateKey ^js (account)
                                  (types/clj->json {:privateKey private-key})
                                  callback))
 
@@ -198,13 +233,13 @@
   "NOTE: beware, the password has to be sha3 hashed"
   [address hashed-password callback]
   (log/debug "[native-module] verify")
-  (.verify ^js (status) address hashed-password callback))
+  (.verify ^js (account) address hashed-password callback))
 
 (defn verify-database-password
   "NOTE: beware, the password has to be sha3 hashed"
   [key-uid hashed-password callback]
   (log/debug "[native-module] verify-database-password")
-  (.verifyDatabasePassword ^js (status) key-uid hashed-password callback))
+  (.verifyDatabasePassword ^js (account) key-uid hashed-password callback))
 
 (defn login-with-keycard
   [{:keys [key-uid multiaccount-data password chat-key node-config]}]
@@ -212,40 +247,40 @@
   (clear-web-data)
   (init-keystore
    key-uid
-   #(.loginWithKeycard ^js (status) multiaccount-data password chat-key (types/clj->json node-config))))
+   #(.loginWithKeycard ^js (account) multiaccount-data password chat-key (types/clj->json node-config))))
 
 (defn set-soft-input-mode
   [mode]
   (log/debug "[native-module]  set-soft-input-mode")
-  (.setSoftInputMode ^js (status) mode))
+  (.setSoftInputMode ^js (ui-helper) mode))
 
 (defn call-rpc
   [payload callback]
   (log/debug "[native-module] call-rpc")
-  (.callRPC ^js (status) payload callback))
+  (.callRPC ^js (network) payload callback))
 
 (defn call-private-rpc
   [payload callback]
-  (.callPrivateRPC ^js (status) payload callback))
+  (.callPrivateRPC ^js (network) payload callback))
 
 (defn hash-transaction
   "used for keycard"
   [rpcParams callback]
   (log/debug "[native-module] hash-transaction")
-  (.hashTransaction ^js (status) rpcParams callback))
+  (.hashTransaction ^js (encryption) rpcParams callback))
 
 (defn hash-message
   "used for keycard"
   [message callback]
   (log/debug "[native-module] hash-message")
-  (.hashMessage ^js (status) message callback))
+  (.hashMessage ^js (encryption) message callback))
 
 (defn start-searching-for-local-pairing-peers
   "starts a UDP multicast beacon that both listens for and broadcasts to LAN peers"
   [callback]
   (log/info "[native-module] Start Searching for Local Pairing Peers"
             {:fn :start-searching-for-local-pairing-peers})
-  (.startSearchForLocalPairingPeers ^js (status) callback))
+  (.startSearchForLocalPairingPeers ^js (network) callback))
 
 (defn local-pairing-preflight-outbound-check
   "Checks whether the device has allows connecting to the local server"
@@ -260,7 +295,7 @@
   (log/info "[native-module] Fetching Connection String"
             {:fn          :get-connection-string-for-bootstrapping-another-device
              :config-json config-json})
-  (.getConnectionStringForBootstrappingAnotherDevice ^js (status) config-json callback))
+  (.getConnectionStringForBootstrappingAnotherDevice ^js (network) config-json callback))
 
 (defn input-connection-string-for-bootstrapping
   "Provides connection string to status-go for the purpose of local pairing on the receiver end"
@@ -269,7 +304,7 @@
             {:fn                :input-connection-string-for-bootstrapping
              :config-json       config-json
              :connection-string connection-string})
-  (.inputConnectionStringForBootstrapping ^js (status) connection-string config-json callback))
+  (.inputConnectionStringForBootstrapping ^js (network) connection-string config-json callback))
 
 (defn deserialize-and-compress-key
   "Provides a community id (public key) to status-go which is first deserialized
@@ -280,7 +315,7 @@
   (log/info "[native-module] Deserializing and then compressing public key"
             {:fn  :deserialize-and-compress-key
              :key input-key})
-  (.deserializeAndCompressKey ^js (status) input-key callback))
+  (.deserializeAndCompressKey ^js (encryption) input-key callback))
 
 (defn compressed-key->public-key
   "Provides compressed key to status-go and gets back the uncompressed public key via deserialization"
@@ -288,59 +323,59 @@
   (log/info "[native-module] Deserializing compressed key"
             {:fn         :compressed-key->public-key
              :public-key public-key})
-  (.multiformatDeserializePublicKey ^js (status) public-key deserialization-key callback))
+  (.multiformatDeserializePublicKey ^js (encryption) public-key deserialization-key callback))
 
 (defn hash-typed-data
   "used for keycard"
   [data callback]
   (log/debug "[native-module] hash-typed-data")
-  (.hashTypedData ^js (status) data callback))
+  (.hashTypedData ^js (encryption) data callback))
 
 (defn hash-typed-data-v4
   "used for keycard"
   [data callback]
   (log/debug "[native-module] hash-typed-data-v4")
-  (.hashTypedDataV4 ^js (status) data callback))
+  (.hashTypedDataV4 ^js (encryption) data callback))
 
 (defn send-transaction-with-signature
   "used for keycard"
   [rpcParams sig callback]
   (log/debug "[native-module] send-transaction-with-signature")
-  (.sendTransactionWithSignature ^js (status) rpcParams sig callback))
+  (.sendTransactionWithSignature ^js (network) rpcParams sig callback))
 
 (defn sign-message
   "NOTE: beware, the password in rpcParams has to be sha3 hashed"
   [rpcParams callback]
   (log/debug "[native-module] sign-message")
-  (.signMessage ^js (status) rpcParams callback))
+  (.signMessage ^js (encryption) rpcParams callback))
 
 (defn recover-message
   [rpcParams callback]
   (log/debug "[native-module] recover")
-  (.recover ^js (status) rpcParams callback))
+  (.recover ^js (network) rpcParams callback))
 
 (defn send-transaction
   "NOTE: beware, the password has to be sha3 hashed"
   [rpcParams hashed-password callback]
   (log/debug "[native-module] send-transaction")
-  (.sendTransaction ^js (status) rpcParams hashed-password callback))
+  (.sendTransaction ^js (network) rpcParams hashed-password callback))
 
 (defn sign-typed-data
   "NOTE: beware, the password has to be sha3 hashed"
   [data account hashed-password callback]
   (log/debug "[native-module] sign-typed-data")
-  (.signTypedData ^js (status) data account hashed-password callback))
+  (.signTypedData ^js (encryption) data account hashed-password callback))
 
 (defn sign-typed-data-v4
   "NOTE: beware, the password has to be sha3 hashed"
   [data account hashed-password callback]
   (log/debug "[native-module] sign-typed-data-v4")
-  (.signTypedDataV4 ^js (status) data account hashed-password callback))
+  (.signTypedDataV4 ^js (encryption) data account hashed-password callback))
 
 (defn send-logs
   [dbJson js-logs callback]
   (log/debug "[native-module] send-logs")
-  (.sendLogs ^js (status) dbJson js-logs callback))
+  (.sendLogs ^js (log-manager) dbJson js-logs callback))
 
 (defn close-application
   []
@@ -365,7 +400,7 @@
 (defn set-blank-preview-flag
   [flag]
   (log/debug "[native-module] set-blank-preview-flag")
-  (.setBlankPreviewFlag ^js (status) flag))
+  (.setBlankPreviewFlag ^js (encryption) flag))
 
 (defn get-device-model-info
   []
@@ -393,7 +428,7 @@
 (defn toggle-webview-debug
   [on]
   (log/debug "[native-module] toggle-webview-debug" on)
-  (.toggleWebviewDebug ^js (status) on))
+  (.toggleWebviewDebug ^js (ui-helper) on))
 
 (defn rooted-device?
   [callback]
@@ -416,72 +451,72 @@
 (defn encode-transfer
   [to-norm amount-hex]
   (log/debug "[native-module] encode-transfer")
-  (.encodeTransfer ^js (status) to-norm amount-hex))
+  (.encodeTransfer ^js (encryption) to-norm amount-hex))
 
 (defn decode-parameters
   [bytes-string types]
   (log/debug "[native-module] decode-parameters")
-  (let [json-str (.decodeParameters ^js (status)
+  (let [json-str (.decodeParameters ^js (encryption)
                                     (types/clj->json {:bytesString bytes-string :types types}))]
     (types/json->clj json-str)))
 
 (defn hex-to-number
   [hex]
   (log/debug "[native-module] hex-to-number")
-  (let [json-str (.hexToNumber ^js (status) hex)]
+  (let [json-str (.hexToNumber ^js (encryption) hex)]
     (types/json->clj json-str)))
 
 (defn number-to-hex
   [num]
   (log/debug "[native-module] number-to-hex")
-  (.numberToHex ^js (status) (str num)))
+  (.numberToHex ^js (encryption) (str num)))
 
 (defn sha3
   [s]
   (log/debug "[native-module] sha3")
   (when s
-    (.sha3 ^js (status) (str s))))
+    (.sha3 ^js (encryption) (str s))))
 
 (defn utf8-to-hex
   [s]
   (log/debug "[native-module] utf8-to-hex")
-  (.utf8ToHex ^js (status) s))
+  (.utf8ToHex ^js (encryption) s))
 
 (defn hex-to-utf8
   [s]
   (log/debug "[native-module] hex-to-utf8")
-  (.hexToUtf8 ^js (status) s))
+  (.hexToUtf8 ^js (encryption) s))
 
 (defn check-address-checksum
   [address]
   (log/debug "[native-module] check-address-checksum")
-  (let [result (.checkAddressChecksum ^js (status) address)]
+  (let [result (.checkAddressChecksum ^js (utils) address)]
     (types/json->clj result)))
 
 (defn address?
   [address]
   (log/debug "[native-module] address?")
   (when address
-    (let [result (.isAddress ^js (status) address)]
+    (let [result (.isAddress ^js (utils) address)]
       (types/json->clj result))))
 
 (defn to-checksum-address
   [address]
   (log/debug "[native-module] to-checksum-address")
-  (.toChecksumAddress ^js (status) address))
+  (.toChecksumAddress ^js (utils) address))
 
 (defn validate-mnemonic
   "Validate that a mnemonic conforms to BIP39 dictionary/checksum standards"
   [mnemonic callback]
   (log/debug "[native-module] validate-mnemonic")
-  (.validateMnemonic ^js (status) mnemonic callback))
+  (.validateMnemonic ^js (utils) mnemonic callback))
 
 (defn delete-multiaccount
   "Delete multiaccount from database, deletes multiaccount's database and
   key files."
   [key-uid callback]
   (log/debug "[native-module] delete-multiaccount")
-  (.deleteMultiaccount ^js (status) key-uid callback))
+  (.deleteMultiaccount ^js (account) key-uid callback))
 
 (defn delete-imported-key
   "Delete imported key file."
@@ -493,7 +528,7 @@
   [input selection]
   (log/debug "[native-module] resetKeyboardInput")
   (when platform/android?
-    (.resetKeyboardInputCursor ^js (status) input selection)))
+    (.resetKeyboardInputCursor ^js (ui-helper) input selection)))
 
 ;; passwords are hashed
 (defn reset-password
@@ -501,12 +536,12 @@
   (log/debug "[native-module] change-database-password")
   (init-keystore
    key-uid
-   #(.reEncryptDbAndKeystore ^js (status) key-uid current-password# new-password# callback)))
+   #(.reEncryptDbAndKeystore ^js (encryption) key-uid current-password# new-password# callback)))
 
 (defn convert-to-keycard-account
   [{:keys [key-uid] :as multiaccount-data} settings current-password# new-password callback]
   (log/debug "[native-module] convert-to-keycard-account")
-  (.convertToKeycardAccount ^js (status)
+  (.convertToKeycardAccount ^js (encryption)
                             key-uid
                             (types/clj->json multiaccount-data)
                             (types/clj->json settings)
@@ -517,7 +552,7 @@
 
 (defn backup-disabled-data-dir
   []
-  (.backupDisabledDataDir ^js (status)))
+  (.backupDisabledDataDir ^js (utils)))
 
 (defn fleets
   []
@@ -525,12 +560,12 @@
 
 (defn keystore-dir
   []
-  (.keystoreDir ^js (status)))
+  (.keystoreDir ^js (utils)))
 
 (defn log-file-directory
   []
-  (.logFileDirectory ^js (status)))
+  (.logFileDirectory ^js (log-manager)))
 
 (defn init-status-go-logging
   [{:keys [enable? mobile-system? log-level callback]}]
-  (.initLogging ^js (status) enable? mobile-system? log-level callback))
+  (.initLogging ^js (log-manager) enable? mobile-system? log-level callback))