WIP - Capsule Wallet

android/app/src/main/java/org/celo/mobile/CapsuleSignerModule.java

@@ -0,0 +1,59 @@
+package org.celo.mobile;
+
+import android.util.Log;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import signer.Signer;
+
+public class CapsuleSignerModule extends ReactContextBaseJavaModule {
+  static final String TAG = "CapsuleSignerModule";
+
+  String ids = "[\"USER\",\"RECOVERY\",\"CAPSULE\"]";
+  int threshold = 2;
+  String userId = "USER";
+  String recoveryId = "RECOVERY";
+  String serverUrl = "http://mpcnetworkloadbalancer-348316826.us-west-1.elb.amazonaws.com";
+  String configBase =
+    "{\"ServerUrl\": \"%s\", \"WalletId\": \"%s\", \"Id\":\"%s\", \"Ids\":%s, \"Threshold\":1}";
+
+  CapsuleSignerModule(ReactApplicationContext context) {
+    super(context);
+  }
+
+  @Override
+  public String getName() {
+    return "CapsuleSignerModule";
+  }
+
+  /**
+   * Perform distributed key generation with the Capsule server
+   *
+   * @param protocolId
+   * @return
+   */
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String createAccount(String walletId, String protocolId) {
+    String userStr = String.format(configBase, serverUrl, walletId, userId, ids);
+    String recoveryStr = String.format(configBase, serverUrl, walletId, recoveryId, ids);
+
+    // Run DKG as both user and recovery
+    // Signer.createAccount(serverUrl, recoveryStr, protocolId);
+    return Signer.createAccount(serverUrl, userStr, protocolId);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String getAddress(String serializedSigner) {
+    return Signer.getAddress(serializedSigner);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String sendTransaction(String protocolId, String serializedSigner, String transaction) {
+    return Signer.sendTransaction(serverUrl, serializedSigner, "hello world", protocolId);
+  }
+}

android/app/src/main/java/org/celo/mobile/SignerPackage.java → android/app/src/main/java/org/celo/mobile/CapsuleSignerPackage.java

@@ -8,7 +8,7 @@
 import java.util.Collections;
 import java.util.List;
 
-public class SignerPackage implements ReactPackage {
+public class CapsuleSignerPackage implements ReactPackage {
 
   @Override
   public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
@@ -19,7 +19,7 @@ public List<ViewManager> createViewManagers(ReactApplicationContext reactContext
   public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
     List<NativeModule> modules = new ArrayList<>();
 
-    modules.add(new SignerModule(reactContext));
+    modules.add(new CapsuleSignerModule(reactContext));
 
     return modules;
   }

android/app/src/main/java/org/celo/mobile/MainApplication.java

@@ -42,7 +42,7 @@ public boolean getUseDeveloperSupport() {
     protected List<ReactPackage> getPackages() {
       @SuppressWarnings("UnnecessaryLocalVariable")
       List<ReactPackage> packages = new PackageList(this).getPackages();
-      packages.add(new SignerPackage());
+      packages.add(new CapsuleSignerPackage());
       return packages;
     }
 

src/account/saga.ts

@@ -50,7 +50,12 @@ import { restartApp } from 'src/utils/AppRestart'
 import Logger from 'src/utils/Logger'
 import { getContractKit, getWallet } from 'src/web3/contracts'
 import { registerAccountDek } from 'src/web3/dataEncryptionKey'
-import { getOrCreateAccount, getWalletAddress, unlockAccount } from 'src/web3/saga'
+import {
+  getOrCreateAccount,
+  getOrCreateCapsuleAccount,
+  getWalletAddress,
+  unlockAccount,
+} from 'src/web3/saga'
 import { walletAddressSelector } from 'src/web3/selectors'
 import { finclusiveKycStatusSelector } from './selectors'
 
@@ -88,8 +93,8 @@ function* initializeAccount() {
   Logger.debug(TAG + '@initializeAccount', 'Creating account')
   try {
     ValoraAnalytics.track(OnboardingEvents.initialize_account_start)
-    yield call(getOrCreateAccount)
-    yield call(generateSignedMessage)
+    yield call(getOrCreateCapsuleAccount)
+    //yield call(generateSignedMessage)
     yield put(refreshAllBalances())
     Logger.debug(TAG + '@initializeAccount', 'Account creation success')
     ValoraAnalytics.track(OnboardingEvents.initialize_account_complete)

src/app/ErrorMessages.ts

@@ -94,5 +94,7 @@ export enum ErrorMessages {
   ADD_FIAT_ACCOUNT_RESOURCE_EXIST = 'fiatDetailsScreen.addFiatAccountResourceExist',
   CREATE_PDF_FAILED = 'createPdfFailure',
   FAILED_OPEN_DIRECTION = 'failedOpeningDirections',
-  CREATE_PDF_FAILED = 'createPdfFailure',
+  CAPSULE_FETCH_ACCOUNTS = 'capsuleFetchAccounts',
+  CAPSULE_ACCOUNT_ALREADY_EXISTS = 'capsuleAccountAlreadyExists',
+  CAPSULE_UNEXPECTED_ADDRESS = 'capsuleUnexpectedAddress',
 }

src/backup/utils.ts

@@ -14,6 +14,7 @@ import { currentAccountSelector } from 'src/web3/selectors'
 const TAG = 'Backup/utils'
 
 const MNEMONIC_STORAGE_KEY = 'mnemonic'
+const CAPSULE_KEY_SHARE = 'capsule'
 
 export function getMnemonicLanguage(language: string | null) {
   switch (language?.slice(0, 2)) {
@@ -30,37 +31,73 @@ export function getMnemonicLanguage(language: string | null) {
 }
 
 export async function storeMnemonic(mnemonic: string, account: string | null, password?: string) {
+  return storeEncryptedSecret(MNEMONIC_STORAGE_KEY, mnemonic, account, password)
+}
+
+export async function storeCapsuleKeyShare(
+  mnemonic: string,
+  account: string | null,
+  password?: string
+) {
+  return storeEncryptedSecret(CAPSULE_KEY_SHARE, mnemonic, account, password)
+}
+
+async function storeEncryptedSecret(
+  storageKey: string,
+  mnemonic: string,
+  account: string | null,
+  password?: string
+) {
   if (!account) {
     throw new Error('Account not yet initialized')
   }
   const passwordToUse = password ?? (await getPassword(account))
   const encryptedMnemonic = await encryptMnemonic(mnemonic, passwordToUse)
-  return storeItem({ key: MNEMONIC_STORAGE_KEY, value: encryptedMnemonic })
+  return storeItem({ key: storageKey, value: encryptedMnemonic })
 }
 
 export async function clearStoredMnemonic() {
   await removeStoredItem(MNEMONIC_STORAGE_KEY)
 }
 
+export async function clearCapsuleKeyShare() {
+  await removeStoredItem(CAPSULE_KEY_SHARE)
+}
+
 export async function getStoredMnemonic(
   account: string | null,
   password?: string
+): Promise<string | null> {
+  return getStoredEncryptedSecret(MNEMONIC_STORAGE_KEY, account, password)
+}
+
+export async function getStoredCapsuleKeyShare(
+  account: string | null,
+  password?: string
+): Promise<string | null> {
+  return getStoredEncryptedSecret(CAPSULE_KEY_SHARE, account, password)
+}
+
+async function getStoredEncryptedSecret(
+  storageKey: string,
+  account: string | null,
+  password?: string
 ): Promise<string | null> {
   try {
     if (!account) {
       throw new Error('Account not yet initialized')
     }
 
     Logger.debug(TAG, 'Checking keystore for mnemonic')
-    const encryptedMnemonic = await retrieveStoredItem(MNEMONIC_STORAGE_KEY)
-    if (!encryptedMnemonic) {
+    const encryptedSecret = await retrieveStoredItem(storageKey)
+    if (!encryptedSecret) {
       throw new Error('No mnemonic found in storage')
     }
 
     const passwordToUse = password ?? (await getPassword(account))
-    return decryptMnemonic(encryptedMnemonic, passwordToUse)
+    return decryptSecret(encryptedSecret, passwordToUse)
   } catch (error) {
-    Logger.error(TAG, 'Failed to retrieve mnemonic', error)
+    Logger.error(TAG, 'Failed to retrieve secret', error)
     return null
   }
 }
@@ -111,7 +148,7 @@ export async function encryptMnemonic(phrase: string, password: string) {
   return CryptoJS.AES.encrypt(phrase, password).toString()
 }
 
-export async function decryptMnemonic(encryptedMnemonic: string, password: string) {
-  const bytes = CryptoJS.AES.decrypt(encryptedMnemonic, password)
+export async function decryptSecret(encryptedSecret: string, password: string) {
+  const bytes = CryptoJS.AES.decrypt(encryptedSecret, password)
   return bytes.toString(CryptoJS.enc.Utf8)
 }