react-native-zcash 0.4.2 → 0.6.0

package/ios/ZCashLightClientKit/Block/Download/BlockDownloader.swift

@@ -52,6 +52,14 @@ protocol BlockDownloader {
     /// called before then nothing is downloaded.
     /// - Parameter range: Wait until blocks from `range` are downloaded.
     func waitUntilRequestedBlocksAreDownloaded(in range: CompactBlockRange) async throws
+    
+    /// Updates the internal in memory value of latest downloaded block height. This way the `BlockDownloader` works with the current latest height and can
+    /// continue on parallel downloading of next batch.
+    func update(latestDownloadedBlockHeight: BlockHeight, force: Bool) async
+    /// Provides the value of latest downloaded height.
+    func latestDownloadedBlockHeight() async -> BlockHeight
+    /// In case rewind is needed, the latestDownloadedBlockHeight is rewritten forcefully.
+    func rewind(latestDownloadedBlockHeight: BlockHeight?) async
 }
 
 actor BlockDownloaderImpl {
@@ -62,9 +70,9 @@ actor BlockDownloaderImpl {
     let service: LightWalletService
     let downloaderService: BlockDownloaderService
     let storage: CompactBlockRepository
-    let internalSyncProgress: InternalSyncProgress
     let metrics: SDKMetrics
     let logger: Logger
+    var latestDownloadedBlockHeight: BlockHeight = -1
 
     private var downloadStreamCreatedAtRange: CompactBlockRange = 0...0
     private var downloadStream: BlockDownloaderStream?
@@ -80,14 +88,12 @@ actor BlockDownloaderImpl {
         service: LightWalletService,
         downloaderService: BlockDownloaderService,
         storage: CompactBlockRepository,
-        internalSyncProgress: InternalSyncProgress,
         metrics: SDKMetrics,
         logger: Logger
     ) {
         self.service = service
         self.downloaderService = downloaderService
         self.storage = storage
-        self.internalSyncProgress = internalSyncProgress
         self.metrics = metrics
         self.logger = logger
     }
@@ -100,8 +106,6 @@ actor BlockDownloaderImpl {
                 throw ZcashError.blockDownloadSyncRangeNotSet
             }
 
-            let latestDownloadedBlockHeight = await internalSyncProgress.load(.latestDownloadedBlockHeight)
-
             let downloadFrom = max(syncRange.lowerBound, latestDownloadedBlockHeight + 1)
             let downloadTo = min(downloadToHeight, syncRange.upperBound)
 
@@ -195,13 +199,8 @@ actor BlockDownloaderImpl {
         var counter = 0
         var lastDownloadedBlockHeight = -1
 
-        let pushMetrics: (BlockHeight, Date, Date) -> Void = { [metrics] lastDownloadedBlockHeight, startTime, finishTime in
+        let pushMetrics: (BlockHeight, Date, Date) -> Void = { [metrics] _, startTime, finishTime in
             metrics.pushProgressReport(
-                progress: BlockProgress(
-                    startHeight: totalProgressRange.lowerBound,
-                    targetHeight: totalProgressRange.upperBound,
-                    progressHeight: Int(lastDownloadedBlockHeight)
-                ),
                 start: startTime,
                 end: finishTime,
                 batchSize: maxBlockBufferSize,
@@ -220,7 +219,7 @@ actor BlockDownloaderImpl {
             if buffer.count >= maxBlockBufferSize {
                 let finishTime = Date()
                 try await storage.write(blocks: buffer)
-                await blocksBufferWritten(buffer)
+                try await blocksBufferWritten(buffer)
                 buffer.removeAll(keepingCapacity: true)
 
                 pushMetrics(block.height, startTime, finishTime)
@@ -235,21 +234,36 @@ actor BlockDownloaderImpl {
         }
 
         try await storage.write(blocks: buffer)
-        await blocksBufferWritten(buffer)
+        try await blocksBufferWritten(buffer)
     }
 
-    private func blocksBufferWritten(_ buffer: [ZcashCompactBlock]) async {
+    private func blocksBufferWritten(_ buffer: [ZcashCompactBlock]) async throws {
         guard let lastBlock = buffer.last else { return }
-        await internalSyncProgress.set(lastBlock.height, .latestDownloadedBlockHeight)
+        latestDownloadedBlockHeight = lastBlock.height
     }
 }
 
 extension BlockDownloaderImpl: BlockDownloader {
+    func rewind(latestDownloadedBlockHeight: BlockHeight?) async {
+        self.latestDownloadedBlockHeight = latestDownloadedBlockHeight ?? -1
+    }
+    
+    func update(latestDownloadedBlockHeight: BlockHeight, force: Bool = false) async {
+        if latestDownloadedBlockHeight >= self.latestDownloadedBlockHeight || force {
+            self.latestDownloadedBlockHeight = latestDownloadedBlockHeight
+        }
+    }
+
+    func latestDownloadedBlockHeight() async -> BlockHeight {
+        latestDownloadedBlockHeight
+    }
+
     func setDownloadLimit(_ limit: BlockHeight) async {
         downloadToHeight = limit
     }
 
     func setSyncRange(_ range: CompactBlockRange, batchSize: Int) async throws {
+        guard range != syncRange else { return }
         downloadStream = nil
         self.batchSize = batchSize
         syncRange = range
@@ -282,13 +296,13 @@ extension BlockDownloaderImpl: BlockDownloader {
 
     func waitUntilRequestedBlocksAreDownloaded(in range: CompactBlockRange) async throws {
         logger.debug("Waiting until requested blocks are downloaded at \(range)")
-        var latestDownloadedBlock = await internalSyncProgress.load(.latestDownloadedBlockHeight)
+        var latestDownloadedBlock = latestDownloadedBlockHeight
         while latestDownloadedBlock < range.upperBound {
             if let error = lastError {
                 throw error
             }
             try await Task.sleep(milliseconds: 10)
-            latestDownloadedBlock = await internalSyncProgress.load(.latestDownloadedBlockHeight)
+            latestDownloadedBlock = latestDownloadedBlockHeight
         }
         logger.debug("Waiting done. Blocks are downloaded at \(range)")
     }

package/ios/ZCashLightClientKit/Block/Download/BlockDownloaderService.swift

@@ -107,8 +107,8 @@ extension BlockDownloaderServiceImpl: BlockDownloaderService {
         try await self.storage.rewind(to: height)
     }
 
-    func lastDownloadedBlockHeight() async -> BlockHeight {
-        await self.storage.latestHeight()
+    func lastDownloadedBlockHeight() async throws -> BlockHeight {
+        try await self.storage.latestHeight()
     }
     
     func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched {

package/ios/ZCashLightClientKit/Block/Enhance/BlockEnhancer.swift

@@ -7,13 +7,56 @@
 
 import Foundation
 
+public struct EnhancementProgress: Equatable {
+    /// total transactions that were detected in the `range`
+    public let totalTransactions: Int
+    /// enhanced transactions so far
+    public let enhancedTransactions: Int
+    /// last found transaction
+    public let lastFoundTransaction: ZcashTransaction.Overview?
+    /// block range that's being enhanced
+    public let range: CompactBlockRange
+    /// whether this transaction can be considered `newly mined` and not part of the
+    /// wallet catching up to stale and uneventful blocks.
+    public let newlyMined: Bool
+
+    public init(
+        totalTransactions: Int,
+        enhancedTransactions: Int,
+        lastFoundTransaction: ZcashTransaction.Overview?,
+        range: CompactBlockRange,
+        newlyMined: Bool
+    ) {
+        self.totalTransactions = totalTransactions
+        self.enhancedTransactions = enhancedTransactions
+        self.lastFoundTransaction = lastFoundTransaction
+        self.range = range
+        self.newlyMined = newlyMined
+    }
+
+    public var progress: Float {
+        totalTransactions > 0 ? Float(enhancedTransactions) / Float(totalTransactions) : 0
+    }
+
+    public static var zero: EnhancementProgress {
+        EnhancementProgress(totalTransactions: 0, enhancedTransactions: 0, lastFoundTransaction: nil, range: 0...0, newlyMined: false)
+    }
+
+    public static func == (lhs: EnhancementProgress, rhs: EnhancementProgress) -> Bool {
+        return
+            lhs.totalTransactions == rhs.totalTransactions &&
+            lhs.enhancedTransactions == rhs.enhancedTransactions &&
+            lhs.lastFoundTransaction?.rawID == rhs.lastFoundTransaction?.rawID &&
+            lhs.range == rhs.range
+    }
+}
+
 protocol BlockEnhancer {
-    func enhance(at range: CompactBlockRange, didEnhance: (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]?
+    func enhance(at range: CompactBlockRange, didEnhance: @escaping (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]?
 }
 
 struct BlockEnhancerImpl {
     let blockDownloaderService: BlockDownloaderService
-    let internalSyncProgress: InternalSyncProgress
     let rustBackend: ZcashRustBackendWelding
     let transactionRepository: TransactionRepository
     let metrics: SDKMetrics
@@ -38,7 +81,7 @@ struct BlockEnhancerImpl {
 }
 
 extension BlockEnhancerImpl: BlockEnhancer {
-    func enhance(at range: CompactBlockRange, didEnhance: (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]? {
+    func enhance(at range: CompactBlockRange, didEnhance: @escaping (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]? {
         try Task.checkCancellation()
         
         logger.debug("Started Enhancing range: \(range)")
@@ -52,7 +95,6 @@ extension BlockEnhancerImpl: BlockEnhancer {
             let transactions = try await transactionRepository.find(in: range, limit: Int.max, kind: .all)
 
             guard !transactions.isEmpty else {
-                await internalSyncProgress.set(range.upperBound, .latestEnhancedHeight)
                 logger.debug("no transactions detected on range: \(range.lowerBound)...\(range.upperBound)")
                 return nil
             }
@@ -82,10 +124,6 @@ extension BlockEnhancerImpl: BlockEnhancer {
                         )
 
                         await didEnhance(progress)
-
-                        if let minedHeight = confirmedTx.minedHeight {
-                            await internalSyncProgress.set(minedHeight, .latestEnhancedHeight)
-                        }
                     } catch {
                         retries += 1
                         logger.error("could not enhance txId \(transaction.rawID.toHexStringTxId()) - Error: \(error)")
@@ -97,11 +135,6 @@ extension BlockEnhancerImpl: BlockEnhancer {
             }
             
             metrics.pushProgressReport(
-                progress: BlockProgress(
-                    startHeight: range.lowerBound,
-                    targetHeight: range.upperBound,
-                    progressHeight: range.upperBound
-                ),
                 start: startTime,
                 end: Date(),
                 batchSize: range.count,
@@ -111,8 +144,6 @@ extension BlockEnhancerImpl: BlockEnhancer {
             logger.error("error enhancing transactions! \(error)")
             throw error
         }
-
-        await internalSyncProgress.set(range.upperBound, .latestEnhancedHeight)
         
         if Task.isCancelled {
             logger.debug("Warning: compactBlockEnhancement on range \(range) cancelled")

package/ios/ZCashLightClientKit/Block/FetchUnspentTxOutputs/UTXOFetcher.swift

@@ -18,8 +18,7 @@ struct UTXOFetcherConfig {
 
 protocol UTXOFetcher {
     func fetch(
-        at range: CompactBlockRange,
-        didFetch: (Float) async -> Void
+        didFetch: @escaping (Float) async -> Void
     ) async throws -> (inserted: [UnspentTransactionOutputEntity], skipped: [UnspentTransactionOutputEntity])
 }
 
@@ -27,7 +26,6 @@ struct UTXOFetcherImpl {
     let accountRepository: AccountRepository
     let blockDownloaderService: BlockDownloaderService
     let config: UTXOFetcherConfig
-    let internalSyncProgress: InternalSyncProgress
     let rustBackend: ZcashRustBackendWelding
     let metrics: SDKMetrics
     let logger: Logger
@@ -35,8 +33,7 @@ struct UTXOFetcherImpl {
 
 extension UTXOFetcherImpl: UTXOFetcher {
     func fetch(
-        at range: CompactBlockRange,
-        didFetch: (Float) async -> Void
+        didFetch: @escaping (Float) async -> Void
     ) async throws -> (inserted: [UnspentTransactionOutputEntity], skipped: [UnspentTransactionOutputEntity]) {
         try Task.checkCancellation()
 
@@ -82,7 +79,6 @@ extension UTXOFetcherImpl: UTXOFetcher {
 
                 counter += 1
                 await didFetch(counter / all)
-                await internalSyncProgress.set(utxo.height, .latestUTXOFetchedHeight)
             } catch {
                 logger.error("failed to put utxo - error: \(error)")
                 skipped.append(utxo)
@@ -90,23 +86,16 @@ extension UTXOFetcherImpl: UTXOFetcher {
         }
 
         metrics.pushProgressReport(
-            progress: BlockProgress(
-                startHeight: range.lowerBound,
-                targetHeight: range.upperBound,
-                progressHeight: range.upperBound
-            ),
             start: startTime,
             end: Date(),
-            batchSize: range.count,
+            batchSize: 1,
             operation: .fetchUTXOs
         )
 
         let result = (inserted: refreshed, skipped: skipped)
 
-        await internalSyncProgress.set(range.upperBound, .latestUTXOFetchedHeight)
-
         if Task.isCancelled {
-            logger.debug("Warning: fetchUnspentTxOutputs on range \(range) cancelled")
+            logger.debug("Warning: fetchUnspentTxOutputs cancelled")
         }
 
         return result

package/ios/ZCashLightClientKit/Block/FilesystemStorage/FSCompactBlockRepository.swift

@@ -64,8 +64,8 @@ extension FSCompactBlockRepository: CompactBlockRepository {
         }
     }
 
-    func latestHeight() async -> BlockHeight {
-        await metadataStore.latestHeight()
+    func latestHeight() async throws -> BlockHeight {
+        try await metadataStore.latestHeight()
     }
 
     func write(blocks: [ZcashCompactBlock]) async throws {
@@ -251,7 +251,7 @@ struct FSMetadataStore {
     let saveBlocksMeta: ([ZcashCompactBlock]) async throws -> Void
     let rewindToHeight: (BlockHeight) async throws -> Void
     let initFsBlockDbRoot: () async throws -> Void
-    let latestHeight: () async -> BlockHeight
+    let latestHeight: () async throws -> BlockHeight
 }
 
 extension FSMetadataStore {
@@ -268,7 +268,7 @@ extension FSMetadataStore {
         } initFsBlockDbRoot: {
             try await rustBackend.initBlockMetadataDb()
         } latestHeight: {
-            await rustBackend.latestCachedBlockHeight()
+            try await rustBackend.latestCachedBlockHeight()
         }
     }
 }

package/ios/ZCashLightClientKit/Block/Scan/BlockScanner.swift

@@ -16,8 +16,7 @@ protocol BlockScanner {
     @discardableResult
     func scanBlocks(
         at range: CompactBlockRange,
-        totalProgressRange: CompactBlockRange,
-        didScan: @escaping (BlockHeight) async -> Void
+        didScan: @escaping (BlockHeight, UInt32) async throws -> Void
     ) async throws -> BlockHeight
 }
 
@@ -27,20 +26,18 @@ struct BlockScannerImpl {
     let transactionRepository: TransactionRepository
     let metrics: SDKMetrics
     let logger: Logger
-    let latestBlocksDataProvider: LatestBlocksDataProvider
 }
 
 extension BlockScannerImpl: BlockScanner {
     @discardableResult
     func scanBlocks(
         at range: CompactBlockRange,
-        totalProgressRange: CompactBlockRange,
-        didScan: @escaping (BlockHeight) async -> Void
+        didScan: @escaping (BlockHeight, UInt32) async throws -> Void
     ) async throws -> BlockHeight {
         logger.debug("Going to scan blocks in range: \(range)")
         try Task.checkCancellation()
 
-        let scanStartHeight = try await transactionRepository.lastScannedHeight()
+        let scanStartHeight = range.lowerBound
         let targetScanHeight = range.upperBound
 
         var scannedNewBlocks = false
@@ -50,13 +47,13 @@ extension BlockScannerImpl: BlockScanner {
             try Task.checkCancellation()
 
             let previousScannedHeight = lastScannedHeight
+            let startHeight = previousScannedHeight + 1
 
-            // TODO: [#576] remove this arbitrary batch size https://github.com/zcash/ZcashLightClientKit/issues/576
-            let batchSize = scanBatchSize(startScanHeight: previousScannedHeight + 1, network: config.networkType)
+            let batchSize = UInt32(config.scanningBatchSize)
 
             let scanStartTime = Date()
             do {
-                try await self.rustBackend.scanBlocks(limit: batchSize)
+                try await self.rustBackend.scanBlocks(fromHeight: Int32(startHeight), limit: batchSize)
             } catch {
                 logger.debug("block scanning failed with error: \(String(describing: error))")
                 throw error
@@ -64,24 +61,15 @@ extension BlockScannerImpl: BlockScanner {
 
             let scanFinishTime = Date()
 
-            if let lastScannedBlock = try await transactionRepository.lastScannedBlock() {
-                lastScannedHeight = lastScannedBlock.height
-                await latestBlocksDataProvider.updateLatestScannedHeight(lastScannedHeight)
-                await latestBlocksDataProvider.updateLatestScannedTime(TimeInterval(lastScannedBlock.time))
-            }
+            // TODO: [#1259] potential bug when rustBackend.scanBlocks scan less blocks than batchSize,
+            // https://github.com/zcash/ZcashLightClientKit/issues/1259
+            lastScannedHeight = startHeight + Int(batchSize) - 1
             
             scannedNewBlocks = previousScannedHeight != lastScannedHeight
             if scannedNewBlocks {
-                await didScan(lastScannedHeight)
-
-                let progress = BlockProgress(
-                    startHeight: totalProgressRange.lowerBound,
-                    targetHeight: totalProgressRange.upperBound,
-                    progressHeight: lastScannedHeight
-                )
+                try await didScan(lastScannedHeight, batchSize)
 
                 metrics.pushProgressReport(
-                    progress: progress,
                     start: scanStartTime,
                     end: scanFinishTime,
                     batchSize: Int(batchSize),
@@ -98,17 +86,4 @@ extension BlockScannerImpl: BlockScanner {
 
         return lastScannedHeight
     }
-
-    private func scanBatchSize(startScanHeight height: BlockHeight, network: NetworkType) -> UInt32 {
-        assert(config.scanningBatchSize > 0, "ZcashSDK.DefaultScanningBatch must be larger than 0!")
-        guard network == .mainnet else { return UInt32(config.scanningBatchSize) }
-
-        if height > 1_650_000 {
-            // librustzcash thread saturation at a number of blocks
-            // that contains 100 * num_cores Sapling outputs.
-            return UInt32(max(ProcessInfo().activeProcessorCount, 10))
-        }
-
-        return UInt32(config.scanningBatchSize)
-    }
 }

package/ios/ZCashLightClientKit/Block/Utils/CompactBlockProgress.swift

@@ -0,0 +1,24 @@
+//
+//  CompactBlockProgress.swift
+//  
+//
+//  Created by Michal Fousek on 11.05.2023.
+//
+
+import Foundation
+
+final actor CompactBlockProgress {
+    static let zero = CompactBlockProgress()
+
+    var progress: Float = 0.0
+
+    func hasProgressUpdated(_ event: CompactBlockProcessor.Event) -> Bool {
+        guard case .syncProgress(let update) = event else {
+            return false
+        }
+
+        progress = update
+        
+        return true
+    }
+}

package/ios/ZCashLightClientKit/Block/Utils/SyncControlData.swift

@@ -0,0 +1,25 @@
+//
+//  SyncControlData.swift
+//  
+//
+//  Created by Michal Fousek on 23.11.2022.
+//
+
+import Foundation
+
+struct SyncControlData: Equatable {
+    /// The tip of the blockchain
+    let latestBlockHeight: BlockHeight
+    /// The last height that has been scanned
+    let latestScannedHeight: BlockHeight?
+    /// The height from the enhancement must start
+    let firstUnenhancedHeight: BlockHeight?
+    
+    static var empty: SyncControlData {
+        SyncControlData(
+            latestBlockHeight: 0,
+            latestScannedHeight: nil,
+            firstUnenhancedHeight: nil
+        )
+    }
+}

package/ios/ZCashLightClientKit/ClosureSynchronizer.swift

@@ -24,8 +24,8 @@ public protocol ClosureSynchronizer {
 
     func prepare(
         with seed: [UInt8]?,
-        viewingKeys: [UnifiedFullViewingKey],
         walletBirthday: BlockHeight,
+        for walletMode: WalletInitMode,
         completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
     )
 
@@ -51,7 +51,6 @@ public protocol ClosureSynchronizer {
         completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
     )
 
-    func pendingTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
     func clearedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
     func sentTranscations(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
     func receivedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)

package/ios/ZCashLightClientKit/CombineSynchronizer.swift

@@ -24,8 +24,8 @@ public protocol CombineSynchronizer {
 
     func prepare(
         with seed: [UInt8]?,
-        viewingKeys: [UnifiedFullViewingKey],
-        walletBirthday: BlockHeight
+        walletBirthday: BlockHeight,
+        for walletMode: WalletInitMode
     ) -> SinglePublisher<Initializer.InitializationResult, Error>
 
     func start(retry: Bool) -> CompletablePublisher<Error>
@@ -49,7 +49,6 @@ public protocol CombineSynchronizer {
     ) -> SinglePublisher<ZcashTransaction.Overview, Error>
 
     var allTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
-    var pendingTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
     var sentTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
     var receivedTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
 
@@ -59,8 +58,6 @@ public protocol CombineSynchronizer {
 
     func getRecipients(for transaction: ZcashTransaction.Overview) -> SinglePublisher<[TransactionRecipient], Never>
 
-    func allPendingTransactions() -> SinglePublisher<[ZcashTransaction.Overview], Error>
-
     func allTransactions(from transaction: ZcashTransaction.Overview, limit: Int) -> SinglePublisher<[ZcashTransaction.Overview], Error>
 
     func latestHeight() -> SinglePublisher<BlockHeight, Error>

package/ios/ZCashLightClientKit/Constants/ZcashSDK.swift

@@ -88,17 +88,10 @@ public enum ZcashSDK {
     // MARK: Defaults
 
     /// Default size of batches of blocks to request from the compact block service. Which was used both for scanning and downloading.
-    /// consider basing your code assumptions on `DefaultDownloadBatch` and `DefaultScanningBatch` instead.
-    @available(*, deprecated, message: "this value is being deprecated in favor of `DefaultDownloadBatch` and `DefaultScanningBatch`")
     public static let DefaultBatchSize = 100
-
-    /// Default batch size for downloading blocks for the compact block processor. Be careful with this number. This amount of blocks is held in
-    /// memory at some point of the sync process.
-    /// This values can't be smaller than `DefaultScanningBatch`. Otherwise bad things will happen.
-    public static let DefaultDownloadBatch = 100
-
-    /// Default batch size for scanning blocks for the compact block processor
-    public static let DefaultScanningBatch = 100
+    
+    /// Default batch size for enhancing transactions for the compact block processor
+    public static let DefaultEnhanceBatch = 1000
 
     /// Default amount of time, in in seconds, to poll for new blocks. Typically, this should be about half the average
     /// block time.
@@ -161,19 +154,13 @@ public protocol NetworkConstants {
     /// Default prefix for db filenames
     static var defaultDbNamePrefix: String { get }
 
-    /// fixed height where the SDK considers that the ZIP-321 was deployed. This is a workaround
-    /// for librustzcash not figuring out the tx fee from the tx itself.
-    static var feeChangeHeight: BlockHeight { get }
-
-    /// Returns the default fee according to the blockheight. see [ZIP-313](https://zips.z.cash/zip-0313)
-    static func defaultFee(for height: BlockHeight) -> Zatoshi
+    /// Returns the default fee, hardcoded 10k Zatoshi is the minimum ZIP 317 fee
+    static func defaultFee() -> Zatoshi
 }
 
 public extension NetworkConstants {
-    static func defaultFee(for height: BlockHeight = BlockHeight.max) -> Zatoshi {
-        guard height >= feeChangeHeight else { return Zatoshi(10_000) }
-
-        return Zatoshi(1_000)
+    static func defaultFee() -> Zatoshi {
+        Zatoshi(10_000)
     }
 }
 
@@ -191,8 +178,6 @@ public enum ZcashSDKMainnetConstants: NetworkConstants {
     public static let defaultCacheDbName = "caches.db"
     
     public static let defaultDbNamePrefix = "ZcashSdk_mainnet_"
-    
-    public static let feeChangeHeight: BlockHeight = 1_077_550
 }
 
 public enum ZcashSDKTestnetConstants: NetworkConstants {
@@ -209,7 +194,4 @@ public enum ZcashSDKTestnetConstants: NetworkConstants {
     public static let defaultFsBlockDbRootName = "fs_cache"
     
     public static let defaultDbNamePrefix = "ZcashSdk_testnet_"
-
-    /// Estimated height where wallets are supposed to change the fee
-    public static let feeChangeHeight: BlockHeight = 1_028_500
 }