Merge pull request #393 from code-payments/fix/add-title-back-to-balance

chore: create "generators" for GiftCard, Mnemonic, and Organizer

Author: bmc08gt

api/src/main/java/com/getcode/generator/Generator.kt

@@ -0,0 +1,5 @@
+package com.getcode.generator
+
+interface Generator<D,R> {
+    fun generate(predicate: D): R
+}

api/src/main/java/com/getcode/generator/GiftCardGenerator.kt

@@ -0,0 +1,15 @@
+package com.getcode.generator
+
+import android.content.Context
+import com.getcode.crypt.MnemonicPhrase
+import com.getcode.solana.organizer.GiftCardAccount
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+
+class GiftCardGenerator @Inject constructor(
+    @ApplicationContext private val context: Context
+): Generator<MnemonicPhrase?, GiftCardAccount> {
+    override fun generate(predicate: MnemonicPhrase?): GiftCardAccount {
+        return GiftCardAccount.newInstance(context, predicate)
+    }
+}

api/src/main/java/com/getcode/generator/MnemonicGenerator.kt

@@ -0,0 +1,21 @@
+package com.getcode.generator
+
+import android.content.Context
+import com.getcode.crypt.MnemonicPhrase
+import com.getcode.utils.Base58String
+import com.getcode.utils.Base64String
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+
+class MnemonicGenerator @Inject constructor(
+    @ApplicationContext private val context: Context
+): Generator<Base64String, MnemonicPhrase> {
+
+    override fun generate(predicate: Base64String): MnemonicPhrase {
+        return MnemonicPhrase.fromEntropyB64(context, predicate)
+    }
+
+    fun generateFromBase58(predicate: Base58String): MnemonicPhrase {
+        return MnemonicPhrase.fromEntropyB58(context, predicate)
+    }
+}

api/src/main/java/com/getcode/generator/OrganizerGenerator.kt

@@ -0,0 +1,16 @@
+package com.getcode.generator
+
+import android.content.Context
+import com.getcode.crypt.MnemonicPhrase
+import com.getcode.solana.organizer.Organizer
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+
+class OrganizerGenerator @Inject constructor(
+    @ApplicationContext private val context: Context
+): Generator<MnemonicPhrase, Organizer> {
+
+    override fun generate(predicate: MnemonicPhrase): Organizer {
+        return Organizer.newInstance(context, predicate)
+    }
+}

api/src/main/java/com/getcode/manager/GiftCardManager.kt

@@ -2,15 +2,18 @@ package com.getcode.manager
 
 import android.content.Context
 import com.getcode.crypt.MnemonicPhrase
+import com.getcode.generator.Generator
+import com.getcode.generator.GiftCardGenerator
 import com.getcode.solana.organizer.GiftCardAccount
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
 class GiftCardManager @Inject constructor(
-    @ApplicationContext private val context: Context
+    @ApplicationContext private val context: Context,
+    private val generator: GiftCardGenerator
 ) {
     fun createGiftCard(mnemonic: MnemonicPhrase? = null): GiftCardAccount {
-        return GiftCardAccount.newInstance(context, mnemonic)
+        return generator.generate(mnemonic)
     }
 
     fun getEntropy(giftCard: GiftCardAccount): String {

api/src/main/java/com/getcode/manager/MnemonicManager.kt

@@ -4,18 +4,22 @@ import android.content.Context
 import com.getcode.crypt.MnemonicCode
 import com.getcode.crypt.MnemonicPhrase
 import com.getcode.ed25519.Ed25519.KeyPair
+import com.getcode.generator.MnemonicGenerator
+import com.getcode.utils.Base58String
+import com.getcode.utils.Base64String
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
 class MnemonicManager @Inject constructor(
-    @ApplicationContext private val context: Context
+    @ApplicationContext private val context: Context,
+    private val generator: MnemonicGenerator,
 ) {
-    fun fromCashLink(cashLink: String): MnemonicPhrase {
-        return MnemonicPhrase.fromEntropyB58(context, cashLink)
+    fun fromEntropyBase58(cashLink: Base58String): MnemonicPhrase {
+        return generator.generateFromBase58(cashLink)
     }
 
-    fun fromEntropyBase64(entropy: String): MnemonicPhrase {
-        return MnemonicPhrase.fromEntropyB64(context, entropy)
+    fun fromEntropyBase64(entropy: Base64String): MnemonicPhrase {
+        return generator.generate(entropy)
     }
 
     fun getKeyPair(entropy: String): KeyPair {

api/src/main/java/com/getcode/manager/SessionManager.kt

@@ -1,20 +1,14 @@
 package com.getcode.manager
 
-import android.content.Context
-import com.getcode.crypt.MnemonicPhrase
 import com.getcode.ed25519.Ed25519
-import com.getcode.model.Domain
-import com.getcode.network.TipController
+import com.getcode.generator.OrganizerGenerator
 import com.getcode.network.client.Client
-import com.getcode.network.client.awaitEstablishRelationship
-import com.getcode.network.client.establishRelationshipSingle
 import com.getcode.network.client.registerInstallation
 import com.getcode.network.client.updatePreferences
 import com.getcode.solana.organizer.Organizer
 import com.getcode.utils.installationId
 import com.google.firebase.Firebase
 import com.google.firebase.installations.installations
-import com.ionspin.kotlin.crypto.LibsodiumInitializer
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -27,6 +21,8 @@ import javax.inject.Singleton
 @Singleton
 class SessionManager @Inject constructor(
     private val client: Client,
+    private val mnemonicManager: MnemonicManager,
+    private val organizerGenerator: OrganizerGenerator,
 ) {
     data class SessionState(
         val entropyB64: String? = null,
@@ -37,15 +33,13 @@ class SessionManager @Inject constructor(
         val userPrefsUpdated: Boolean = false,
     )
 
-    fun set(context: Context, entropyB64: String) {
-        val mnemonic = MnemonicPhrase.fromEntropyB64(context, entropyB64)
+    fun set(entropyB64: String) {
+        val mnemonic = mnemonicManager.fromEntropyBase64(entropyB64)
         if (getOrganizer()?.mnemonic?.words == mnemonic.words
             && getOrganizer()?.ownerKeyPair == authState.value.keyPair
         ) return
-        val organizer = Organizer.newInstance(
-            context = context,
-            mnemonic = mnemonic
-        )
+
+        val organizer = organizerGenerator.generate(mnemonic)
 
         update {
             SessionState(

api/src/main/java/com/getcode/utils/String.kt

@@ -28,4 +28,7 @@ fun String.base64EncodedData(): ByteArray {
         return data + padding.toByteArray()
     }
     return data
-}
+}
+
+typealias Base64String = String
+typealias Base58String = String

app/src/main/java/com/getcode/manager/AuthManager.kt

@@ -98,7 +98,7 @@ class AuthManager @Inject constructor(
             }
 
             val originalSessionState = SessionManager.authState.value
-            sessionManager.set(context, entropyB64)
+            sessionManager.set(entropyB64)
 
             if (!isSoftLogin) {
                 loginAnalytics(entropyB64)
@@ -220,7 +220,7 @@ class AuthManager @Inject constructor(
             .flatMap {
                 user = it
                 if (SessionManager.authState.value.entropyB64 != entropyB64) {
-                    sessionManager.set(context, entropyB64)
+                    sessionManager.set(entropyB64)
                 }
                 balanceController.fetchBalance()
                     .toSingleDefault(Pair(phone!!, user!!))

app/src/main/java/com/getcode/view/main/home/HomeViewModel.kt

@@ -276,7 +276,6 @@ class HomeViewModel @Inject constructor(
             }
             .map { it }
             .distinctUntilChanged()
-            .onEach { Timber.d("airdrop eligible=$it") }
             .filter { it }
             .mapNotNull { SessionManager.getKeyPair() }
             .catchSafely(
@@ -1489,24 +1488,24 @@ class HomeViewModel @Inject constructor(
         }
     }
 
-    fun openCashLink(deepLink: String?) {
-        Timber.d("openCashLink: deep link=$deepLink")
-        val cashLink = deepLink?.trim()?.replace("\n", "") ?: return
-        if (cashLink.isEmpty()) {
+    fun openCashLink(cashLink: String?) {
+        Timber.d("openCashLink:$cashLink")
+        val base58Entropy = cashLink?.trim()?.replace("\n", "") ?: return
+        if (base58Entropy.isEmpty()) {
             Timber.d("cash link empty")
             return
         }
-        if (openedLinks.contains(cashLink)) {
+        if (openedLinks.contains(base58Entropy)) {
             Timber.d("cash link already opened in session")
             return
         }
 
         analytics.cashLinkGrabStart()
 
-        openedLinks.add(cashLink)
+        openedLinks.add(base58Entropy)
 
         try {
-            val mnemonic = mnemonicManager.fromCashLink(cashLink)
+            val mnemonic = mnemonicManager.fromEntropyBase58(base58Entropy)
             val giftCardAccount = giftCardManager.createGiftCard(mnemonic)
 
             viewModelScope.launch {
@@ -1536,15 +1535,15 @@ class HomeViewModel @Inject constructor(
                                     ),
                                     vibrate = true
                                 )
-                                removeLinkWithDelay(cashLink)
+                                removeLinkWithDelay(base58Entropy)
                             }
                         } catch (ex: Exception) {
                             ex.printStackTrace()
                             Timber.e(ex)
                             when (ex) {
                                 is RemoteSendException -> {
                                     onRemoteSendError(ex)
-                                    removeLinkWithDelay(cashLink)
+                                    removeLinkWithDelay(base58Entropy)
                                 }
 
                                 else -> {