feat: transfer to spending from hw wallet

app/src/main/java/to/bitkit/data/HwWalletStore.kt

@@ -11,7 +11,7 @@ import kotlinx.coroutines.withContext
 import kotlinx.serialization.Serializable
 import to.bitkit.data.serializers.HwWalletDataSerializer
 import to.bitkit.di.IoDispatcher
-import to.bitkit.repositories.KnownDevice
+import to.bitkit.models.KnownDevice
 import javax.inject.Inject
 import javax.inject.Singleton
 

app/src/main/java/to/bitkit/data/dao/TransferDao.kt

@@ -10,6 +10,7 @@ import kotlinx.coroutines.flow.Flow
 import to.bitkit.data.entities.TransferEntity
 
 @Dao
+@Suppress("TooManyFunctions")
 interface TransferDao {
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun insert(transfer: TransferEntity)
@@ -35,6 +36,9 @@ interface TransferDao {
     @Query("SELECT * FROM transfers WHERE id = :id LIMIT 1")
     suspend fun getById(id: String): TransferEntity?
 
+    @Query("SELECT * FROM transfers WHERE fundingTxId = :fundingTxId LIMIT 1")
+    suspend fun getByFundingTxId(fundingTxId: String): TransferEntity?
+
     @Query("UPDATE transfers SET isSettled = 1, settledAt = :settledAt WHERE id = :id")
     suspend fun markSettled(id: String, settledAt: Long)
 

app/src/main/java/to/bitkit/env/Env.kt

@@ -263,6 +263,9 @@ object Defaults {
     /** Recommended transaction base fee in sats */
     const val recommendedBaseFee = 256u
 
+    /** Fallback fee percentage used when fee estimates are temporarily unavailable. */
+    const val fallbackFeePercent = 0.1
+
     /**
      * Minimum value in sats for an output. Outputs below the dust limit may not be processed because the fees
      * required to include them in a block would be greater than the value of the transaction itself.

app/src/main/java/to/bitkit/ext/TrezorTransportType.kt

@@ -0,0 +1,9 @@
+package to.bitkit.ext
+
+import com.synonym.bitkitcore.TrezorTransportType
+import to.bitkit.models.TransportType
+
+fun TrezorTransportType.toTransportType(): TransportType = when (this) {
+    TrezorTransportType.BLUETOOTH -> TransportType.BLUETOOTH
+    TrezorTransportType.USB -> TransportType.USB
+}

app/src/main/java/to/bitkit/models/HardwareWallet.kt

@@ -0,0 +1,98 @@
+package to.bitkit.models
+
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.Stable
+import com.synonym.bitkitcore.AccountType
+import com.synonym.bitkitcore.Activity
+import com.synonym.bitkitcore.AddressType
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.ImmutableSet
+import kotlinx.collections.immutable.persistentSetOf
+import kotlinx.serialization.Serializable
+
+/** A paired hardware wallet tracked as a watch-only balance. */
+@Stable
+data class HwWallet(
+    val id: String,
+    val name: String,
+    val model: String?,
+    val transportType: TransportType,
+    val isConnected: Boolean,
+    val balanceSats: ULong,
+    val activities: ImmutableList<Activity>,
+    val fundingBalanceSats: ULong = balanceSats,
+    val deviceIds: ImmutableSet<String> = persistentSetOf(id),
+)
+
+/** Serializable per-device balance snapshot carried by [BalanceState]. */
+@Immutable
+@Serializable
+data class HwWalletBalance(
+    val id: String,
+    val sats: ULong,
+)
+
+/** A newly detected inbound transaction to a watched hardware wallet. */
+@Immutable
+data class HwWalletReceivedTx(
+    val txid: String,
+    val sats: ULong,
+)
+
+sealed interface HwFundingAccount {
+    val vendor: HwWalletVendor
+    val xpub: String
+    val addressType: HwFundingAddressType
+    val accountType: AccountType
+    val balanceSats: ULong
+
+    data class Trezor(
+        override val xpub: String,
+        override val addressType: HwFundingAddressType,
+        override val balanceSats: ULong,
+    ) : HwFundingAccount {
+        override val vendor: HwWalletVendor = HwWalletVendor.TREZOR
+        override val accountType: AccountType
+            get() = addressType.accountType
+    }
+}
+
+data class HwFundingTransaction(
+    val psbt: String,
+    val miningFeeSats: ULong,
+    val feeRate: Float,
+    val totalSpent: ULong,
+    val satsPerVByte: ULong,
+)
+
+data class HwFundingBroadcastResult(
+    val txId: String,
+    val miningFeeSats: ULong,
+    val feeRate: ULong,
+    val totalSpent: ULong,
+)
+
+enum class HwWalletVendor {
+    TREZOR,
+}
+
+enum class HwFundingAddressType(
+    val addressType: AddressType,
+) {
+    LEGACY(AddressType.P2PKH),
+    NESTED_SEGWIT(AddressType.P2SH),
+    NATIVE_SEGWIT(AddressType.P2WPKH),
+    TAPROOT(AddressType.P2TR);
+
+    val settingsKey: String
+        get() = addressType.toSettingsString()
+
+    val accountType: AccountType
+        get() = addressType.toAccountType()
+
+    companion object {
+        val DEFAULT: HwFundingAddressType = entries.first { it.addressType == DEFAULT_ADDRESS_TYPE }
+    }
+}
+
+fun HwWallet.toBalance() = HwWalletBalance(id = id, sats = balanceSats)

app/src/main/java/to/bitkit/models/KnownDevice.kt

@@ -0,0 +1,22 @@
+package to.bitkit.models
+
+import androidx.compose.runtime.Immutable
+import kotlinx.serialization.Serializable
+
+@Serializable
+@Immutable
+data class KnownDevice(
+    val id: String,
+    val name: String?,
+    val path: String,
+    val transportType: TransportType,
+    val label: String?,
+    val model: String?,
+    val lastConnectedAt: Long,
+    /** Account-level extended public keys per address type. */
+    val xpubs: Map<String, String> = emptyMap(),
+    /** Bitkit-side funds label set by the user while pairing; null until renamed within Bitkit. */
+    val customLabel: String? = null,
+    /** Stable app-owned id for future wallet-scoped hardware activity metadata. */
+    val walletId: String = "",
+)

app/src/main/java/to/bitkit/repositories/ActivityRepo.kt

@@ -213,6 +213,26 @@ class ActivityRepo @Inject constructor(
         notifyActivitiesChanged()
     }
 
+    suspend fun syncHardwareOnchainActivity(activity: OnchainActivity): Result<Unit> = withContext(bgDispatcher) {
+        runCatching {
+            val existing = coreService.activity.getOnchainActivityByTxId(activity.txId) ?: return@runCatching
+            val confirmTimestamp = existing.confirmTimestamp ?: activity.confirmTimestamp ?: activity.timestamp
+                .takeIf { activity.confirmed }
+            val updated = existing.copy(
+                confirmed = existing.confirmed || activity.confirmed,
+                confirmTimestamp = confirmTimestamp,
+                doesExist = if (activity.confirmed) true else existing.doesExist,
+                fee = if (existing.fee == 0uL && activity.fee > 0uL) activity.fee else existing.fee,
+                updatedAt = maxOf(existing.updatedAt ?: 0uL, activity.updatedAt ?: activity.timestamp),
+            )
+            if (updated == existing) return@runCatching
+            coreService.activity.update(existing.id, Activity.Onchain(updated))
+            notifyActivitiesChanged()
+        }.onFailure {
+            Logger.error("Failed to sync hardware activity '${activity.txId}'", it, context = TAG)
+        }
+    }
+
     suspend fun handleOnchainTransactionReplaced(txid: String, conflicts: List<String>) {
         coreService.activity.handleOnchainTransactionReplaced(txid, conflicts)
         notifyActivitiesChanged()