[Electric-Coin-Company#1452] TX Resubmission-the wallet has to period…

…ically resubmit unmined transactions

- functional version is done

[Electric-Coin-Company#1452] TX Resubmission-the wallet has to periodically resubmit unmined transactions

- code cleanup

[Electric-Coin-Company#1452] TX Resubmission-the wallet has to periodically resubmit unmined transactions

- changelog updated

CHANGELOG.md

@@ -6,6 +6,11 @@ and this library adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 # Unreleased
 
+## Added
+
+### [#452] TX Resubmission-the wallet has to periodically resubmit unmined transactions
+The Compact block processor's state machine has been extended to check whether there are any unmined and unexpired transactions, and it attempts to resubmit such transactions every 5 minutes.
+
 # 2.1.10 - 2024-06-14
 
 ## Fixed

Example/ZcashLightClientSample/ZcashLightClientSample/DemoAppConfig.swift

@@ -18,8 +18,8 @@ enum DemoAppConfig {
         let seed: [UInt8]
     }
 
-    static let host = ZcashSDK.isMainnet ? "mainnet.lightwalletd.com" : "lightwalletd.testnet.electriccoin.co"
-    static let port: Int = 9067
+    static let host = ZcashSDK.isMainnet ? "zec.rocks" : "lightwalletd.testnet.electriccoin.co"
+    static let port: Int = 443
 
     static let defaultBirthdayHeight: BlockHeight = ZcashSDK.isMainnet ? 935000 : 1386000
 

Example/ZcashLightClientSample/ZcashLightClientSample/Send/SendViewController.swift

@@ -247,6 +247,7 @@ class SendViewController: UIViewController {
                 KRProgressHUD.dismiss()
                 loggerProxy.info("transaction created: \(pendingTransaction)")
             } catch {
+                KRProgressHUD.dismiss()
                 fail(error)
                 loggerProxy.error("SEND FAILED: \(error)")
             }

Sources/ZcashLightClientKit/Block/Actions/Action.swift

@@ -73,6 +73,7 @@ enum CBPState: CaseIterable {
     case fetchUTXO
     case handleSaplingParams
     case clearCache
+    case txResubmission
     case finished
     case failed
     case stopped

Sources/ZcashLightClientKit/Block/Actions/EnhanceAction.swift

@@ -28,7 +28,7 @@ final class EnhanceAction {
         if lastScannedHeight >= latestBlockHeight {
             await context.update(state: .clearCache)
         } else {
-            await context.update(state: .updateChainTip)
+            await context.update(state: .txResubmission)
         }
 
         return context

Sources/ZcashLightClientKit/Block/Actions/ProcessSuggestedScanRangesAction.swift

@@ -59,7 +59,7 @@ extension ProcessSuggestedScanRangesAction: Action {
 
             await context.update(state: .download)
         } else {
-            await context.update(state: .finished)
+            await context.update(state: .txResubmission)
         }
 
         return context

Sources/ZcashLightClientKit/Block/Actions/TxResubmissionAction.swift

@@ -0,0 +1,74 @@
+//
+//  TxResubmissionAction.swift
+//
+//
+//  Created by Lukas Korba on 06-17-2024.
+//
+
+import Foundation
+
+final class TxResubmissionAction {
+    private enum Constants {
+        static let thresholdToTrigger = TimeInterval(300.0)
+    }
+
+    var latestResolvedTime: TimeInterval = 0
+    let transactionRepository: TransactionRepository
+    let transactionEncoder: TransactionEncoder
+    let logger: Logger
+
+    init(container: DIContainer) {
+        transactionRepository = container.resolve(TransactionRepository.self)
+        transactionEncoder = container.resolve(TransactionEncoder.self)
+        logger = container.resolve(Logger.self)
+    }
+}
+
+extension TxResubmissionAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { true }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        let latestBlockHeight = await context.syncControlData.latestBlockHeight
+
+        // find all candidates for the resubmission
+        do {
+            let transactions = try await transactionRepository.findForResubmission(upTo: latestBlockHeight)
+
+            // no candidates, update the time and continue with the next action
+            if transactions.isEmpty {
+                latestResolvedTime = Date().timeIntervalSince1970
+            } else {
+                let now = Date().timeIntervalSince1970
+                let diff = now - latestResolvedTime
+
+                // the last time resubmission was triggered is more than 5 minutes ago so try again
+                if diff > Constants.thresholdToTrigger {
+                    // resubmission
+                    do {
+                        for transaction in transactions {
+                            let encodedTransaction = try transaction.encodedTransaction()
+
+                            try await transactionEncoder.submit(transaction: encodedTransaction)
+                            logger.info("TxResubmissionAction trying to resubmit transaction")
+                        }
+                    } catch {
+                        logger.error("TxResubmissionAction failed to resubmit candidates")
+                    }
+
+                    latestResolvedTime = Date().timeIntervalSince1970
+                }
+            }
+        } catch {
+            logger.error("TxResubmissionAction failed to find candidates")
+        }
+
+        if await context.prevState == .enhance {
+            await context.update(state: .updateChainTip)
+        } else {
+            await context.update(state: .finished)
+        }
+        return context
+    }
+
+    func stop() async { }
+}

Sources/ZcashLightClientKit/Block/CompactBlockProcessor.swift

@@ -228,6 +228,8 @@ actor CompactBlockProcessor {
                 action = SaplingParamsAction(container: container)
             case .clearCache:
                 action = ClearCacheAction(container: container)
+            case .txResubmission:
+                action = TxResubmissionAction(container: container)
             case .finished, .failed, .stopped, .idle:
                 return nil
             }
@@ -667,6 +669,8 @@ extension CompactBlockProcessor {
             break
         case .stopped:
             break
+        case .txResubmission:
+            break
         }
     }
 

Sources/ZcashLightClientKit/DAO/TransactionDao.swift

@@ -108,6 +108,19 @@ class TransactionSQLDAO: TransactionRepository {
         return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
+    func findForResubmission(upTo: BlockHeight) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
+            .filter(
+                ZcashTransaction.Overview.Column.minedHeight == nil &&
+                ZcashTransaction.Overview.Column.expiryHeight > upTo
+            )
+            .filterQueryFor(kind: .sent)
+            .limit(Int.max)
+
+        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
     func findReceived(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
         let query = transactionsView
             .filterQueryFor(kind: .received)

Sources/ZcashLightClientKit/Repository/TransactionRepository.swift

@@ -19,6 +19,7 @@ protocol TransactionRepository {
     func findPendingTransactions(latestHeight: BlockHeight, offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview]
     func findReceived(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview]
     func findSent(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview]
+    func findForResubmission(upTo: BlockHeight) async throws -> [ZcashTransaction.Overview]
     // sourcery: mockedName="findMemosForRawID"
     func findMemos(for rawID: Data) async throws -> [Memo]
     // sourcery: mockedName="findMemosForZcashTransaction"

Sources/ZcashLightClientKit/Synchronizer/Dependencies.swift

@@ -96,6 +96,25 @@ enum Dependencies {
         container.register(type: ZcashFileManager.self, isSingleton: true) { _ in
             FileManager.default
         }
+
+        container.register(type: TransactionEncoder.self, isSingleton: true) { di in
+            let service = di.resolve(LightWalletService.self)
+            let logger = di.resolve(Logger.self)
+            let transactionRepository = di.resolve(TransactionRepository.self)
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+
+            return WalletTransactionEncoder(
+                rustBackend: rustBackend,
+                dataDb: urls.dataDbURL,
+                fsBlockDbRoot: urls.fsBlockDbRoot,
+                service: service,
+                repository: transactionRepository,
+                outputParams: urls.outputParamsURL,
+                spendParams: urls.spendParamsURL,
+                networkType: networkType,
+                logger: logger
+            )
+        }
     }
 
     static func setupCompactBlockProcessor(