Updated on 2026-08-14

data/transaction/src/main/java/com/tangem/data/transaction/DefaultMemoValidatorFacade.kt

@@ -0,0 +1,42 @@
+package com.tangem.data.transaction
+
+import com.tangem.blockchain.common.memo.MemoState
+import com.tangem.blockchain.extensions.Result
+import com.tangem.blockchainsdk.BlockchainSDKFactory
+import com.tangem.blockchainsdk.utils.toBlockchain
+import com.tangem.domain.models.network.Network
+import com.tangem.domain.transaction.MemoValidatorFacade
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.coroutines.withContext
+
+internal class DefaultMemoValidatorFacade(
+    private val blockchainSDKFactory: BlockchainSDKFactory,
+    private val dispatchers: CoroutineDispatcherProvider,
+) : MemoValidatorFacade {
+
+    override suspend fun isMemoRequired(network: Network, destinationAddress: String): Boolean =
+        withContext(dispatchers.io) {
+            val blockchain = network.toBlockchain()
+            val factory = blockchainSDKFactory.getMemoValidatorFactorySync() ?: return@withContext false
+            val validator = factory.create(blockchain)
+            when (val result = validator.isMemoRequired(destinationAddress)) {
+                is Result.Success -> result.data
+                is Result.Failure -> false
+            }
+        }
+
+    override suspend fun validateMemo(network: Network, memo: String): Boolean = withContext(dispatchers.io) {
+        val blockchain = network.toBlockchain()
+        val factory = blockchainSDKFactory.getMemoValidatorFactorySync() ?: return@withContext true
+        val validator = factory.create(blockchain)
+        when (val result = validator.validateMemo(memo)) {
+            is Result.Success -> when (result.data) {
+                MemoState.Valid,
+                MemoState.NotSupported,
+                -> true
+                MemoState.Invalid -> false
+            }
+            is Result.Failure -> true
+        }
+    }
+}

data/transaction/src/main/java/com/tangem/data/transaction/DefaultWalletAddressServiceRepository.kt

@@ -6,12 +6,10 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.NameResolver
 import com.tangem.blockchain.common.ResolveAddressResult
 import com.tangem.blockchain.common.ReverseResolveAddressResult
-import com.tangem.blockchain.common.TransactionValidator
-import com.tangem.blockchain.common.memo.MemoState
-import com.tangem.blockchain.extensions.Result
 import com.tangem.blockchainsdk.utils.toBlockchain
 import com.tangem.domain.models.network.Network
 import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.transaction.MemoValidatorFacade
 import com.tangem.domain.transaction.WalletAddressServiceRepository
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.models.ParsedQrCode
@@ -21,6 +19,7 @@ import kotlinx.coroutines.withContext
 
 class DefaultWalletAddressServiceRepository(
     private val walletManagersFacade: WalletManagersFacade,
+    private val memoValidatorFacade: MemoValidatorFacade,
     private val dispatchers: CoroutineDispatcherProvider,
 ) : WalletAddressServiceRepository {
 
@@ -96,28 +95,11 @@ class DefaultWalletAddressServiceRepository(
             }
         }
 
-    override suspend fun validateMemo(userWalletId: UserWalletId, network: Network, memo: String): Boolean =
-        withContext(dispatchers.io) {
-            val walletManager = walletManagersFacade.getOrCreateWalletManager(
-                userWalletId = userWalletId,
-                network = network,
-            ) ?: return@withContext true
+    override suspend fun validateMemo(network: Network, memo: String): Boolean =
+        memoValidatorFacade.validateMemo(network, memo)
 
-            val memoStateResult = (walletManager as? TransactionValidator)?.validateMemo(memo)
-            if (memoStateResult != null) {
-                when (memoStateResult) {
-                    is Result.Success -> when (memoStateResult.data) {
-                        MemoState.NotSupported,
-                        MemoState.Valid,
-                        -> true
-                        MemoState.Invalid -> false
-                    }
-                    is Result.Failure -> true
-                }
-            } else {
-                true
-            }
-        }
+    override suspend fun isMemoRequired(network: Network, destinationAddress: String): Boolean =
+        memoValidatorFacade.isMemoRequired(network, destinationAddress)
 
     override suspend fun parseSharedAddress(input: String, network: Network): ParsedQrCode {
         val blockchain = network.toBlockchain()

data/transaction/src/main/java/com/tangem/data/transaction/di/TransactionDataModule.kt

@@ -3,15 +3,18 @@ package com.tangem.data.transaction.di
 import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.transaction.DefaultFeeRepository
 import com.tangem.data.transaction.DefaultGaslessTransactionRepository
+import com.tangem.data.transaction.DefaultMemoValidatorFacade
 import com.tangem.data.transaction.DefaultTransactionRepository
 import com.tangem.data.transaction.DefaultWalletAddressServiceRepository
 import com.tangem.data.transaction.error.DefaultFeeErrorResolver
+import com.tangem.blockchainsdk.BlockchainSDKFactory
 import com.tangem.datasource.api.gasless.GaslessTxServiceApi
 import com.tangem.datasource.api.tangemTech.TangemTechApi
 import com.tangem.datasource.local.walletmanager.WalletManagersStore
 import com.tangem.domain.demo.models.DemoConfig
 import com.tangem.domain.transaction.FeeRepository
 import com.tangem.domain.transaction.GaslessTransactionRepository
+import com.tangem.domain.transaction.MemoValidatorFacade
 import com.tangem.domain.transaction.TransactionRepository
 import com.tangem.domain.transaction.WalletAddressServiceRepository
 import com.tangem.domain.transaction.error.FeeErrorResolver
@@ -52,14 +55,28 @@ internal object TransactionDataModule {
         )
     }
 
+    @Provides
+    @Singleton
+    fun providesMemoValidatorFacade(
+        blockchainSDKFactory: BlockchainSDKFactory,
+        coroutineDispatcherProvider: CoroutineDispatcherProvider,
+    ): MemoValidatorFacade {
+        return DefaultMemoValidatorFacade(
+            blockchainSDKFactory = blockchainSDKFactory,
+            dispatchers = coroutineDispatcherProvider,
+        )
+    }
+
     @Provides
     @Singleton
     fun providesWalletAddressServiceRepository(
         walletManagersFacade: WalletManagersFacade,
+        memoValidatorFacade: MemoValidatorFacade,
         coroutineDispatcherProvider: CoroutineDispatcherProvider,
     ): WalletAddressServiceRepository {
         return DefaultWalletAddressServiceRepository(
             walletManagersFacade = walletManagersFacade,
+            memoValidatorFacade = memoValidatorFacade,
             dispatchers = coroutineDispatcherProvider,
         )
     }